1/* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2002-2017 Apple Inc. All rights reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 * This code is completely 100% portable C. It does not depend on any external header files
18 * from outside the mDNS project -- all the types it expects to find are defined right here.
19 *
20 * The previous point is very important: This file does not depend on any external
21 * header files. It should compile on *any* platform that has a C compiler, without
22 * making *any* assumptions about availability of so-called "standard" C functions,
23 * routines, or types (which may or may not be present on any given platform).
24 */
25
26#include "DNSCommon.h" // Defines general DNS utility routines
27#include "uDNS.h" // Defines entry points into unicast-specific routines
28#include "nsec.h"
29#include "dnssec.h"
30#include "anonymous.h"
31
32// Disable certain benign warnings with Microsoft compilers
33#if (defined(_MSC_VER))
34// Disable "conditional expression is constant" warning for debug macros.
35// Otherwise, this generates warnings for the perfectly natural construct "while(1)"
36// If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know
37 #pragma warning(disable:4127)
38
39// Disable "assignment within conditional expression".
40// Other compilers understand the convention that if you place the assignment expression within an extra pair
41// of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary.
42// The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal
43// to the compiler that the assignment is intentional, we have to just turn this warning off completely.
44 #pragma warning(disable:4706)
45#endif
46
47#include "dns_sd.h" // for kDNSServiceFlags* definitions
48#include "dns_sd_internal.h"
49
50#define IID(a) ((int32_t)(intptr_t)(a))
51
52#if APPLE_OSX_mDNSResponder
53#include <WebFilterDNS/WebFilterDNS.h>
54
55// Delay in seconds before disabling multicast after there are no active queries or registrations.
56#define BONJOUR_DISABLE_DELAY 60
57
58#if !NO_WCF
59WCFConnection *WCFConnectionNew(void) __attribute__((weak_import));
60void WCFConnectionDealloc(WCFConnection* c) __attribute__((weak_import));
61
62// Do we really need to define a macro for "if"?
63#define CHECK_WCF_FUNCTION(X) if (X)
64#endif // ! NO_WCF
65
66#else
67
68#define NO_WCF 1
69#endif // APPLE_OSX_mDNSResponder
70
71#if AWD_METRICS
72#include "Metrics.h"
73#endif
74
75#if USE_DNS64
76#include "DNS64.h"
77#endif
78
79#ifdef UNIT_TEST
80#include "unittest.h"
81#endif
82
83// Forward declarations
84mDNSlocal void BeginSleepProcessing(mDNS *const m);
85mDNSlocal void RetrySPSRegistrations(mDNS *const m);
86mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password, mDNSBool unicastOnly);
87mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q);
88mDNSlocal void mDNS_PurgeForQuestion(mDNS *const m, DNSQuestion *q);
89mDNSlocal void CheckForDNSSECRecords(mDNS *const m, DNSQuestion *q);
90mDNSlocal void mDNS_SendKeepalives(mDNS *const m);
91mDNSlocal void mDNS_ExtractKeepaliveInfo(AuthRecord *ar, mDNSu32 *timeout, mDNSAddr *laddr, mDNSAddr *raddr, mDNSEthAddr *eth,
92 mDNSu32 *seq, mDNSu32 *ack, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu16 *win);
93
94mDNSlocal void AdvertiseAllInterfaceRecords(mDNS *const m);
95mDNSlocal void DeadvertiseAllInterfaceRecords(mDNS *const m);
96mDNSlocal void FreeNSECRecords(mDNS *const m, CacheRecord *NSECRecords);
97mDNSlocal void mDNSParseNSEC3Records(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end,
98 const mDNSInterfaceID InterfaceID, CacheRecord **NSEC3Records);
99mDNSlocal mDNSu8 *GetValueForMACAddr(mDNSu8 *ptr, mDNSu8 *limit, mDNSEthAddr *eth);
100
101
102// ***************************************************************************
103#if COMPILER_LIKES_PRAGMA_MARK
104#pragma mark - Program Constants
105#endif
106
107// To Turn OFF mDNS_Tracer set MDNS_TRACER to 0 or undef it
108#define MDNS_TRACER 1
109
110#define NO_HINFO 1
111
112// Any records bigger than this are considered 'large' records
113#define SmallRecordLimit 1024
114
115#define kMaxUpdateCredits 10
116#define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6)
117
118// define special NR_AnswerTo values
119#define NR_AnswerMulticast (mDNSu8*)~0
120#define NR_AnswerUnicast (mDNSu8*)~1
121
122// Question default timeout values
123#define DEFAULT_MCAST_TIMEOUT 5
124#define DEFAULT_LO_OR_P2P_TIMEOUT 5
125
126// The code (see SendQueries() and BuildQuestion()) needs to have the
127// RequestUnicast value set to a value one greater than the number of times you want the query
128// sent with the "request unicast response" (QU) bit set.
129#define SET_QU_IN_FIRST_QUERY 2
130#define kDefaultRequestUnicastCount SET_QU_IN_FIRST_QUERY
131
132// The time needed to offload records to a sleep proxy after powerd sends the kIOMessageSystemWillSleep notification
133#define DARK_WAKE_DELAY_SLEEP 5
134#define kDarkWakeDelaySleep (mDNSPlatformOneSecond * DARK_WAKE_DELAY_SLEEP)
135
136// The maximum number of times we delay probing to prevent spurious conflicts due to stale packets
137#define MAX_CONFLICT_PROCESSING_DELAYS 3
138
139// RFC 6762 defines Passive Observation Of Failures (POOF)
140//
141// A host observes the multicast queries issued by the other hosts on
142// the network. One of the major benefits of also sending responses
143// using multicast is that it allows all hosts to see the responses
144// (or lack thereof) to those queries.
145//
146// If a host sees queries, for which a record in its cache would be
147// expected to be given as an answer in a multicast response, but no
148// such answer is seen, then the host may take this as an indication
149// that the record may no longer be valid.
150//
151// After seeing two or more of these queries, and seeing no multicast
152// response containing the expected answer within ten seconds, then even
153// though its TTL may indicate that it is not yet due to expire, that
154// record SHOULD be flushed from the cache.
155//
156// <https://tools.ietf.org/html/rfc6762#section-10.5>
157
158#define POOF_ENABLED 1
159
160mDNSexport const char *const mDNS_DomainTypeNames[] =
161{
162 "b._dns-sd._udp.", // Browse
163 "db._dns-sd._udp.", // Default Browse
164 "lb._dns-sd._udp.", // Automatic Browse
165 "r._dns-sd._udp.", // Registration
166 "dr._dns-sd._udp." // Default Registration
167};
168
169#ifdef UNICAST_DISABLED
170#define uDNS_IsActiveQuery(q, u) mDNSfalse
171#endif
172
173// ***************************************************************************
174#if COMPILER_LIKES_PRAGMA_MARK
175#pragma mark -
176#pragma mark - General Utility Functions
177#endif
178
179// Returns true if this is a unique, authoritative LocalOnly record that answers questions of type
180// A, AAAA , CNAME, or PTR. The caller should answer the question with this record and not send out
181// the question on the wire if LocalOnlyRecordAnswersQuestion() also returns true.
182// Main use is to handle /etc/hosts records and the LocalOnly PTR records created for localhost.
183#define UniqueLocalOnlyRecord(rr) ((rr)->ARType == AuthRecordLocalOnly && \
184 (rr)->resrec.RecordType & kDNSRecordTypeUniqueMask && \
185 ((rr)->resrec.rrtype == kDNSType_A || (rr)->resrec.rrtype == kDNSType_AAAA || \
186 (rr)->resrec.rrtype == kDNSType_CNAME || \
187 (rr)->resrec.rrtype == kDNSType_PTR))
188
189mDNSlocal void SetNextQueryStopTime(mDNS *const m, const DNSQuestion *const q)
190{
191 mDNS_CheckLock(m);
192
193 if (m->NextScheduledStopTime - q->StopTime > 0)
194 m->NextScheduledStopTime = q->StopTime;
195}
196
197mDNSexport void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q)
198{
199 mDNS_CheckLock(m);
200
201 if (ActiveQuestion(q))
202 {
203 // Depending on whether this is a multicast or unicast question we want to set either:
204 // m->NextScheduledQuery = NextQSendTime(q) or
205 // m->NextuDNSEvent = NextQSendTime(q)
206 mDNSs32 *const timer = mDNSOpaque16IsZero(q->TargetQID) ? &m->NextScheduledQuery : &m->NextuDNSEvent;
207 if (*timer - NextQSendTime(q) > 0)
208 *timer = NextQSendTime(q);
209 }
210}
211
212mDNSlocal void ReleaseAuthEntity(AuthHash *r, AuthEntity *e)
213{
214#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1
215 unsigned int i;
216 for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF;
217#endif
218 e->next = r->rrauth_free;
219 r->rrauth_free = e;
220 r->rrauth_totalused--;
221}
222
223mDNSlocal void ReleaseAuthGroup(AuthHash *r, AuthGroup **cp)
224{
225 AuthEntity *e = (AuthEntity *)(*cp);
226 LogMsg("ReleaseAuthGroup: Releasing AuthGroup %##s", (*cp)->name->c);
227 if ((*cp)->rrauth_tail != &(*cp)->members)
228 LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrauth_tail != &(*cp)->members)");
229 if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name);
230 (*cp)->name = mDNSNULL;
231 *cp = (*cp)->next; // Cut record from list
232 ReleaseAuthEntity(r, e);
233}
234
235mDNSlocal AuthEntity *GetAuthEntity(AuthHash *r, const AuthGroup *const PreserveAG)
236{
237 AuthEntity *e = mDNSNULL;
238
239 if (r->rrauth_lock) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); }
240 r->rrauth_lock = 1;
241
242 if (!r->rrauth_free)
243 {
244 // We allocate just one AuthEntity at a time because we need to be able
245 // free them all individually which normally happens when we parse /etc/hosts into
246 // AuthHash where we add the "new" entries and discard (free) the already added
247 // entries. If we allocate as chunks, we can't free them individually.
248 AuthEntity *storage = mDNSPlatformMemAllocate(sizeof(AuthEntity));
249 storage->next = mDNSNULL;
250 r->rrauth_free = storage;
251 }
252
253 // If we still have no free records, recycle all the records we can.
254 // Enumerating the entire auth is moderately expensive, so when we do it, we reclaim all the records we can in one pass.
255 if (!r->rrauth_free)
256 {
257 mDNSu32 oldtotalused = r->rrauth_totalused;
258 mDNSu32 slot;
259 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
260 {
261 AuthGroup **cp = &r->rrauth_hash[slot];
262 while (*cp)
263 {
264 if ((*cp)->members || (*cp)==PreserveAG) cp=&(*cp)->next;
265 else ReleaseAuthGroup(r, cp);
266 }
267 }
268 LogInfo("GetAuthEntity: Recycled %d records to reduce auth cache from %d to %d",
269 oldtotalused - r->rrauth_totalused, oldtotalused, r->rrauth_totalused);
270 }
271
272 if (r->rrauth_free) // If there are records in the free list, take one
273 {
274 e = r->rrauth_free;
275 r->rrauth_free = e->next;
276 if (++r->rrauth_totalused >= r->rrauth_report)
277 {
278 LogInfo("RR Auth now using %ld objects", r->rrauth_totalused);
279 if (r->rrauth_report < 100) r->rrauth_report += 10;
280 else if (r->rrauth_report < 1000) r->rrauth_report += 100;
281 else r->rrauth_report += 1000;
282 }
283 mDNSPlatformMemZero(e, sizeof(*e));
284 }
285
286 r->rrauth_lock = 0;
287
288 return(e);
289}
290
291mDNSexport AuthGroup *AuthGroupForName(AuthHash *r, const mDNSu32 namehash, const domainname *const name)
292{
293 AuthGroup *ag;
294 const mDNSu32 slot = namehash % AUTH_HASH_SLOTS;
295
296 for (ag = r->rrauth_hash[slot]; ag; ag=ag->next)
297 if (ag->namehash == namehash && SameDomainName(ag->name, name))
298 break;
299 return(ag);
300}
301
302mDNSexport AuthGroup *AuthGroupForRecord(AuthHash *r, const ResourceRecord *const rr)
303{
304 return(AuthGroupForName(r, rr->namehash, rr->name));
305}
306
307mDNSlocal AuthGroup *GetAuthGroup(AuthHash *r, const ResourceRecord *const rr)
308{
309 mDNSu16 namelen = DomainNameLength(rr->name);
310 AuthGroup *ag = (AuthGroup*)GetAuthEntity(r, mDNSNULL);
311 const mDNSu32 slot = rr->namehash % AUTH_HASH_SLOTS;
312 if (!ag) { LogMsg("GetAuthGroup: Failed to allocate memory for %##s", rr->name->c); return(mDNSNULL); }
313 ag->next = r->rrauth_hash[slot];
314 ag->namehash = rr->namehash;
315 ag->members = mDNSNULL;
316 ag->rrauth_tail = &ag->members;
317 ag->NewLocalOnlyRecords = mDNSNULL;
318 if (namelen > sizeof(ag->namestorage))
319 ag->name = mDNSPlatformMemAllocate(namelen);
320 else
321 ag->name = (domainname*)ag->namestorage;
322 if (!ag->name)
323 {
324 LogMsg("GetAuthGroup: Failed to allocate name storage for %##s", rr->name->c);
325 ReleaseAuthEntity(r, (AuthEntity*)ag);
326 return(mDNSNULL);
327 }
328 AssignDomainName(ag->name, rr->name);
329
330 if (AuthGroupForRecord(r, rr)) LogMsg("GetAuthGroup: Already have AuthGroup for %##s", rr->name->c);
331 r->rrauth_hash[slot] = ag;
332 if (AuthGroupForRecord(r, rr) != ag) LogMsg("GetAuthGroup: Not finding AuthGroup for %##s", rr->name->c);
333
334 return(ag);
335}
336
337// Returns the AuthGroup in which the AuthRecord was inserted
338mDNSexport AuthGroup *InsertAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr)
339{
340 AuthGroup *ag;
341
342 (void)m;
343 ag = AuthGroupForRecord(r, &rr->resrec);
344 if (!ag) ag = GetAuthGroup(r, &rr->resrec); // If we don't have a AuthGroup for this name, make one now
345 if (ag)
346 {
347 *(ag->rrauth_tail) = rr; // Append this record to tail of cache slot list
348 ag->rrauth_tail = &(rr->next); // Advance tail pointer
349 }
350 return ag;
351}
352
353mDNSexport AuthGroup *RemoveAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr)
354{
355 AuthGroup *a;
356 AuthRecord **rp;
357
358 a = AuthGroupForRecord(r, &rr->resrec);
359 if (!a) { LogMsg("RemoveAuthRecord: ERROR!! AuthGroup not found for %s", ARDisplayString(m, rr)); return mDNSNULL; }
360 rp = &a->members;
361 while (*rp)
362 {
363 if (*rp != rr)
364 rp=&(*rp)->next;
365 else
366 {
367 // We don't break here, so that we can set the tail below without tracking "prev" pointers
368
369 LogInfo("RemoveAuthRecord: removing auth record %s from table", ARDisplayString(m, rr));
370 *rp = (*rp)->next; // Cut record from list
371 }
372 }
373 // TBD: If there are no more members, release authgroup ?
374 a->rrauth_tail = rp;
375 return a;
376}
377
378mDNSexport CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 namehash, const domainname *const name)
379{
380 CacheGroup *cg;
381 mDNSu32 slot = HashSlotFromNameHash(namehash);
382 for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
383 if (cg->namehash == namehash && SameDomainName(cg->name, name))
384 break;
385 return(cg);
386}
387
388mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const ResourceRecord *const rr)
389{
390 return(CacheGroupForName(m, rr->namehash, rr->name));
391}
392
393mDNSexport mDNSBool mDNS_AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr)
394{
395 NetworkInterfaceInfo *intf;
396
397 if (addr->type == mDNSAddrType_IPv4)
398 {
399 // Normally we resist touching the NotAnInteger fields, but here we're doing tricky bitwise masking so we make an exception
400 if (mDNSv4AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue);
401 for (intf = m->HostInterfaces; intf; intf = intf->next)
402 if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)
403 if (((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) & intf->mask.ip.v4.NotAnInteger) == 0)
404 return(mDNStrue);
405 }
406
407 if (addr->type == mDNSAddrType_IPv6)
408 {
409 if (mDNSv6AddressIsLinkLocal(&addr->ip.v6)) return(mDNStrue);
410 for (intf = m->HostInterfaces; intf; intf = intf->next)
411 if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)
412 if ((((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) & intf->mask.ip.v6.l[0]) == 0) &&
413 (((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) & intf->mask.ip.v6.l[1]) == 0) &&
414 (((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) & intf->mask.ip.v6.l[2]) == 0) &&
415 (((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) & intf->mask.ip.v6.l[3]) == 0))
416 return(mDNStrue);
417 }
418
419 return(mDNSfalse);
420}
421
422mDNSlocal NetworkInterfaceInfo *FirstInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID)
423{
424 NetworkInterfaceInfo *intf = m->HostInterfaces;
425 while (intf && intf->InterfaceID != InterfaceID) intf = intf->next;
426 return(intf);
427}
428
429mDNSlocal NetworkInterfaceInfo *FirstIPv4LLInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID)
430{
431 NetworkInterfaceInfo *intf;
432
433 if (!InterfaceID)
434 return mDNSNULL;
435
436 // Note: We don't check for InterfaceActive, as the active interface could be IPv6 and
437 // we still want to find the first IPv4 Link-Local interface
438 for (intf = m->HostInterfaces; intf; intf = intf->next)
439 {
440 if (intf->InterfaceID == InterfaceID &&
441 intf->ip.type == mDNSAddrType_IPv4 && mDNSv4AddressIsLinkLocal(&intf->ip.ip.v4))
442 {
443 debugf("FirstIPv4LLInterfaceForID: found LL interface with address %.4a", &intf->ip.ip.v4);
444 return intf;
445 }
446 }
447 return (mDNSNULL);
448}
449
450mDNSexport char *InterfaceNameForID(mDNS *const m, const mDNSInterfaceID InterfaceID)
451{
452 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID);
453 return(intf ? intf->ifname : mDNSNULL);
454}
455
456// Caller should hold the lock
457mDNSlocal void GenerateNegativeResponse(mDNS *const m, mDNSInterfaceID InterfaceID, QC_result qc)
458{
459 DNSQuestion *q;
460 if (!m->CurrentQuestion) { LogMsg("GenerateNegativeResponse: ERROR!! CurrentQuestion not set"); return; }
461 q = m->CurrentQuestion;
462 LogInfo("GenerateNegativeResponse: Generating negative response for question %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
463
464 MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, InterfaceID, mDNSNULL);
465
466 // We need to force the response through in the following cases
467 //
468 // a) SuppressUnusable questions that are suppressed
469 // b) Append search domains and retry the question
470 //
471 // The question may not have set Intermediates in which case we don't deliver negative responses. So, to force
472 // through we use "QC_forceresponse".
473 AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, qc);
474 if (m->CurrentQuestion == q) { q->ThisQInterval = 0; } // Deactivate this question
475 // Don't touch the question after this
476 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
477}
478
479mDNSexport void AnswerQuestionByFollowingCNAME(mDNS *const m, DNSQuestion *q, ResourceRecord *rr)
480{
481 const mDNSBool selfref = SameDomainName(&q->qname, &rr->rdata->u.name);
482 if (q->CNAMEReferrals >= 10 || selfref)
483 {
484 LogMsg("AnswerQuestionByFollowingCNAME: %p %##s (%s) NOT following CNAME referral %d%s for %s",
485 q, q->qname.c, DNSTypeName(q->qtype), q->CNAMEReferrals, selfref ? " (Self-Referential)" : "", RRDisplayString(m, rr));
486 }
487 else
488 {
489 const mDNSu32 c = q->CNAMEReferrals + 1; // Stash a copy of the new q->CNAMEReferrals value
490 UDPSocket *sock = q->LocalSocket;
491 mDNSOpaque16 id = q->TargetQID;
492#if AWD_METRICS
493 uDNSMetrics metrics;
494#endif
495
496 q->LocalSocket = mDNSNULL;
497
498 // The SameDomainName check above is to ignore bogus CNAME records that point right back at
499 // themselves. Without that check we can get into a case where we have two duplicate questions,
500 // A and B, and when we stop question A, UpdateQuestionDuplicates copies the value of CNAMEReferrals
501 // from A to B, and then A is re-appended to the end of the list as a duplicate of B (because
502 // the target name is still the same), and then when we stop question B, UpdateQuestionDuplicates
503 // copies the B's value of CNAMEReferrals back to A, and we end up not incrementing CNAMEReferrals
504 // for either of them. This is not a problem for CNAME loops of two or more records because in
505 // those cases the newly re-appended question A has a different target name and therefore cannot be
506 // a duplicate of any other question ('B') which was itself a duplicate of the previous question A.
507
508 // Right now we just stop and re-use the existing query. If we really wanted to be 100% perfect,
509 // and track CNAMEs coming and going, we should really create a subordinate query here,
510 // which we would subsequently cancel and retract if the CNAME referral record were removed.
511 // In reality this is such a corner case we'll ignore it until someone actually needs it.
512
513 LogInfo("AnswerQuestionByFollowingCNAME: %p %##s (%s) following CNAME referral %d for %s",
514 q, q->qname.c, DNSTypeName(q->qtype), q->CNAMEReferrals, RRDisplayString(m, rr));
515
516#if AWD_METRICS
517 if ((q->CNAMEReferrals == 0) && !q->metrics.originalQName)
518 {
519 domainname * qName;
520 mDNSu16 qNameLen;
521
522 qNameLen = DomainNameLength(&q->qname);
523 if ((qNameLen > 0) && (qNameLen <= MAX_DOMAIN_NAME))
524 {
525 qName = mDNSPlatformMemAllocate(qNameLen);
526 if (qName)
527 {
528 mDNSPlatformMemCopy(qName->c, q->qname.c, qNameLen);
529 q->metrics.originalQName = qName;
530 }
531 }
532 }
533 metrics = q->metrics;
534 mDNSPlatformMemZero(&q->metrics, sizeof(q->metrics));
535#endif
536 mDNS_StopQuery_internal(m, q); // Stop old query
537 AssignDomainName(&q->qname, &rr->rdata->u.name); // Update qname
538 q->qnamehash = DomainNameHashValue(&q->qname); // and namehash
539 // If a unicast query results in a CNAME that points to a .local, we need to re-try
540 // this as unicast. Setting the mDNSInterface_Unicast tells mDNS_StartQuery_internal
541 // to try this as unicast query even though it is a .local name
542 if (!mDNSOpaque16IsZero(q->TargetQID) && IsLocalDomain(&q->qname))
543 {
544 LogInfo("AnswerQuestionByFollowingCNAME: Resolving a .local CNAME %p %##s (%s) Record %s",
545 q, q->qname.c, DNSTypeName(q->qtype), RRDisplayString(m, rr));
546 q->InterfaceID = mDNSInterface_Unicast;
547 }
548 mDNS_StartQuery_internal(m, q); // start new query
549 // Record how many times we've done this. We need to do this *after* mDNS_StartQuery_internal,
550 // because mDNS_StartQuery_internal re-initializes CNAMEReferrals to zero
551 q->CNAMEReferrals = c;
552#if AWD_METRICS
553 q->metrics = metrics;
554#endif
555 if (sock)
556 {
557 // If our new query is a duplicate, then it can't have a socket of its own, so we have to close the one we saved.
558 if (q->DuplicateOf) mDNSPlatformUDPClose(sock);
559 else
560 {
561 // Transplant the old socket into the new question, and copy the query ID across too.
562 // No need to close the old q->LocalSocket value because it won't have been created yet (they're made lazily on-demand).
563 q->LocalSocket = sock;
564 q->TargetQID = id;
565 }
566 }
567 }
568}
569
570#ifdef USE_LIBIDN
571
572#include <unicode/uidna.h>
573
574// #define DEBUG_PUNYCODE 1
575
576mDNSlocal mDNSu8 *PunycodeConvert(const mDNSu8 *const src, mDNSu8 *const dst, const mDNSu8 *const end)
577{
578 UErrorCode errorCode = U_ZERO_ERROR;
579 UIDNAInfo info = UIDNA_INFO_INITIALIZER;
580 UIDNA *uts46 = uidna_openUTS46(UIDNA_USE_STD3_RULES|UIDNA_NONTRANSITIONAL_TO_UNICODE, &errorCode);
581 int32_t len = uidna_nameToASCII_UTF8(uts46, (const char *)src+1, src[0], (char *)dst+1, end-(dst+1), &info, &errorCode);
582 uidna_close(uts46);
583 #if DEBUG_PUNYCODE
584 if (errorCode) LogMsg("uidna_nameToASCII_UTF8(%##s) failed errorCode %d", src, errorCode);
585 if (info.errors) LogMsg("uidna_nameToASCII_UTF8(%##s) failed info.errors 0x%08X", src, info.errors);
586 if (len > MAX_DOMAIN_LABEL) LogMsg("uidna_nameToASCII_UTF8(%##s) result too long %d", src, len);
587 #endif
588 if (errorCode || info.errors || len > MAX_DOMAIN_LABEL) return mDNSNULL;
589 *dst = len;
590 return(dst + 1 + len);
591}
592
593mDNSlocal mDNSBool IsHighASCIILabel(const mDNSu8 *d)
594{
595 int i;
596 for (i=1; i<=d[0]; i++) if (d[i] & 0x80) return mDNStrue;
597 return mDNSfalse;
598}
599
600mDNSlocal const mDNSu8 *FindLastHighASCIILabel(const domainname *const d)
601{
602 const mDNSu8 *ptr = d->c;
603 const mDNSu8 *ans = mDNSNULL;
604 while (ptr[0])
605 {
606 const mDNSu8 *const next = ptr + 1 + ptr[0];
607 if (ptr[0] > MAX_DOMAIN_LABEL || next >= d->c + MAX_DOMAIN_NAME) return mDNSNULL;
608 if (IsHighASCIILabel(ptr)) ans = ptr;
609 ptr = next;
610 }
611 return ans;
612}
613
614mDNSlocal mDNSBool PerformNextPunycodeConversion(const DNSQuestion *const q, domainname *const newname)
615{
616 const mDNSu8 *h = FindLastHighASCIILabel(&q->qname);
617 #if DEBUG_PUNYCODE
618 LogMsg("PerformNextPunycodeConversion: %##s (%s) Last High-ASCII Label %##s", q->qname.c, DNSTypeName(q->qtype), h);
619 #endif
620 if (!h) return mDNSfalse; // There are no high-ascii labels to convert
621
622 mDNSu8 *const dst = PunycodeConvert(h, newname->c + (h - q->qname.c), newname->c + MAX_DOMAIN_NAME);
623 if (!dst)
624 return mDNSfalse; // The label was not convertible to Punycode
625 else
626 {
627 // If Punycode conversion of final eligible label was successful, copy the rest of the domainname
628 const mDNSu8 *const src = h + 1 + h[0];
629 const mDNSu8 remainder = DomainNameLength((domainname*)src);
630 if (dst + remainder > newname->c + MAX_DOMAIN_NAME) return mDNSfalse; // Name too long -- cannot be converted to Punycode
631
632 mDNSPlatformMemCopy(newname->c, q->qname.c, h - q->qname.c); // Fill in the leading part
633 mDNSPlatformMemCopy(dst, src, remainder); // Fill in the trailing part
634 #if DEBUG_PUNYCODE
635 LogMsg("PerformNextPunycodeConversion: %##s converted to %##s", q->qname.c, newname->c);
636 #endif
637 return mDNStrue;
638 }
639}
640
641#endif // USE_LIBIDN
642
643// For a single given DNSQuestion pointed to by CurrentQuestion, deliver an add/remove result for the single given AuthRecord
644// Note: All the callers should use the m->CurrentQuestion to see if the question is still valid or not
645mDNSlocal void AnswerLocalQuestionWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord)
646{
647 DNSQuestion *q = m->CurrentQuestion;
648 mDNSBool followcname;
649
650 if (!q)
651 {
652 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: ERROR!! CurrentQuestion NULL while answering with %s", ARDisplayString(m, rr));
653 return;
654 }
655
656 followcname = FollowCNAME(q, &rr->resrec, AddRecord);
657
658 // We should not be delivering results for record types Unregistered, Deregistering, and (unverified) Unique
659 if (!(rr->resrec.RecordType & kDNSRecordTypeActiveMask))
660 {
661 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: *NOT* delivering %s event for local record type %X %s",
662 AddRecord ? "Add" : "Rmv", rr->resrec.RecordType, ARDisplayString(m, rr));
663 return;
664 }
665
666 // Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it
667 if (AddRecord) rr->AnsweredLocalQ = mDNStrue;
668 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
669 if (q->QuestionCallback && !q->NoAnswer)
670 {
671 q->CurrentAnswers += AddRecord ? 1 : -1;
672 if (UniqueLocalOnlyRecord(rr))
673 {
674 if (!followcname || q->ReturnIntermed)
675 {
676 // Don't send this packet on the wire as we answered from /etc/hosts
677 q->ThisQInterval = 0;
678 q->LOAddressAnswers += AddRecord ? 1 : -1;
679 q->QuestionCallback(m, q, &rr->resrec, AddRecord);
680 }
681 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
682 // The callback above could have caused the question to stop. Detect that
683 // using m->CurrentQuestion
684 if (followcname && m->CurrentQuestion == q)
685 AnswerQuestionByFollowingCNAME(m, q, &rr->resrec);
686 return;
687 }
688 else
689 {
690 q->QuestionCallback(m, q, &rr->resrec, AddRecord);
691 }
692 }
693 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
694}
695
696mDNSlocal void AnswerInterfaceAnyQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord)
697{
698 if (m->CurrentQuestion)
699 LogMsg("AnswerInterfaceAnyQuestionsWithLocalAuthRecord: ERROR m->CurrentQuestion already set: %##s (%s)",
700 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
701 m->CurrentQuestion = m->Questions;
702 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
703 {
704 mDNSBool answered;
705 DNSQuestion *q = m->CurrentQuestion;
706 if (RRAny(rr))
707 answered = ResourceRecordAnswersQuestion(&rr->resrec, q);
708 else
709 answered = LocalOnlyRecordAnswersQuestion(rr, q);
710 if (answered)
711 AnswerLocalQuestionWithLocalAuthRecord(m, rr, AddRecord); // MUST NOT dereference q again
712 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
713 m->CurrentQuestion = q->next;
714 }
715 m->CurrentQuestion = mDNSNULL;
716}
717
718// When a new local AuthRecord is created or deleted, AnswerAllLocalQuestionsWithLocalAuthRecord()
719// delivers the appropriate add/remove events to listening questions:
720// 1. It runs though all our LocalOnlyQuestions delivering answers as appropriate,
721// stopping if it reaches a NewLocalOnlyQuestion -- brand-new questions are handled by AnswerNewLocalOnlyQuestion().
722// 2. If the AuthRecord is marked mDNSInterface_LocalOnly or mDNSInterface_P2P, then it also runs though
723// our main question list, delivering answers to mDNSInterface_Any questions as appropriate,
724// stopping if it reaches a NewQuestion -- brand-new questions are handled by AnswerNewQuestion().
725//
726// AnswerAllLocalQuestionsWithLocalAuthRecord is used by the m->NewLocalRecords loop in mDNS_Execute(),
727// and by mDNS_Deregister_internal()
728
729mDNSlocal void AnswerAllLocalQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord)
730{
731 if (m->CurrentQuestion)
732 LogMsg("AnswerAllLocalQuestionsWithLocalAuthRecord ERROR m->CurrentQuestion already set: %##s (%s)",
733 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
734
735 m->CurrentQuestion = m->LocalOnlyQuestions;
736 while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions)
737 {
738 mDNSBool answered;
739 DNSQuestion *q = m->CurrentQuestion;
740 // We are called with both LocalOnly/P2P record or a regular AuthRecord
741 if (RRAny(rr))
742 answered = ResourceRecordAnswersQuestion(&rr->resrec, q);
743 else
744 answered = LocalOnlyRecordAnswersQuestion(rr, q);
745 if (answered)
746 AnswerLocalQuestionWithLocalAuthRecord(m, rr, AddRecord); // MUST NOT dereference q again
747 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
748 m->CurrentQuestion = q->next;
749 }
750
751 m->CurrentQuestion = mDNSNULL;
752
753 // If this AuthRecord is marked LocalOnly or P2P, then we want to deliver it to all local 'mDNSInterface_Any' questions
754 if (rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P)
755 AnswerInterfaceAnyQuestionsWithLocalAuthRecord(m, rr, AddRecord);
756
757}
758
759// ***************************************************************************
760#if COMPILER_LIKES_PRAGMA_MARK
761#pragma mark -
762#pragma mark - Resource Record Utility Functions
763#endif
764
765#define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA)
766
767#define ResourceRecordIsValidAnswer(RR) ( ((RR)->resrec.RecordType & kDNSRecordTypeActiveMask) && \
768 ((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
769 ((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
770 ((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) )
771
772#define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \
773 (ResourceRecordIsValidAnswer(RR) && \
774 ((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID)))
775
776#define DefaultProbeCountForTypeUnique ((mDNSu8)3)
777#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)
778
779// See RFC 6762: "8.3 Announcing"
780// "The Multicast DNS responder MUST send at least two unsolicited responses, one second apart."
781// Send 4, which is really 8 since we send on both IPv4 and IPv6.
782#define InitialAnnounceCount ((mDNSu8)4)
783
784// For goodbye packets we set the count to 3, and for wakeups we set it to 18
785// (which will be up to 15 wakeup attempts over the course of 30 seconds,
786// and then if the machine fails to wake, 3 goodbye packets).
787#define GoodbyeCount ((mDNSu8)3)
788#define WakeupCount ((mDNSu8)18)
789#define MAX_PROBE_RESTARTS ((mDNSu8)20)
790
791// Number of wakeups we send if WakeOnResolve is set in the question
792#define InitialWakeOnResolveCount ((mDNSu8)3)
793
794// Note that the announce intervals use exponential backoff, doubling each time. The probe intervals do not.
795// This means that because the announce interval is doubled after sending the first packet, the first
796// observed on-the-wire inter-packet interval between announcements is actually one second.
797// The half-second value here may be thought of as a conceptual (non-existent) half-second delay *before* the first packet is sent.
798#define DefaultProbeIntervalForTypeUnique (mDNSPlatformOneSecond/4)
799#define DefaultAnnounceIntervalForTypeShared (mDNSPlatformOneSecond/2)
800#define DefaultAnnounceIntervalForTypeUnique (mDNSPlatformOneSecond/2)
801
802#define DefaultAPIntervalForRecordType(X) ((X) &kDNSRecordTypeActiveSharedMask ? DefaultAnnounceIntervalForTypeShared : \
803 (X) &kDNSRecordTypeUnique ? DefaultProbeIntervalForTypeUnique : \
804 (X) &kDNSRecordTypeActiveUniqueMask ? DefaultAnnounceIntervalForTypeUnique : 0)
805
806#define TimeToAnnounceThisRecord(RR,time) ((RR)->AnnounceCount && (time) - ((RR)->LastAPTime + (RR)->ThisAPInterval) >= 0)
807#define TicksTTL(RR) ((mDNSs32)(RR)->resrec.rroriginalttl * mDNSPlatformOneSecond)
808#define RRExpireTime(RR) ((RR)->TimeRcvd + TicksTTL(RR))
809
810// Adjustment factor to avoid race condition (used for unicast cache entries) :
811// Suppose real record has TTL of 3600, and our local caching server has held it for 3500 seconds, so it returns an aged TTL of 100.
812// If we do our normal refresh at 80% of the TTL, our local caching server will return 20 seconds, so we'll do another
813// 80% refresh after 16 seconds, and then the server will return 4 seconds, and so on, in the fashion of Zeno's paradox.
814// To avoid this, we extend the record's effective TTL to give it a little extra grace period.
815// We adjust the 100 second TTL to 127. This means that when we do our 80% query at 102 seconds,
816// the cached copy at our local caching server will already have expired, so the server will be forced
817// to fetch a fresh copy from the authoritative server, and then return a fresh record with the full TTL of 3600 seconds.
818
819#define RRAdjustTTL(ttl) ((ttl) + ((ttl)/4) + 2)
820#define RRUnadjustedTTL(ttl) ((((ttl) - 2) * 4) / 5)
821
822#define MaxUnansweredQueries 4
823
824// SameResourceRecordSignature returns true if two resources records have the same name, type, and class, and may be sent
825// (or were received) on the same interface (i.e. if *both* records specify an interface, then it has to match).
826// TTL and rdata may differ.
827// This is used for cache flush management:
828// When sending a unique record, all other records matching "SameResourceRecordSignature" must also be sent
829// When receiving a unique record, all old cache records matching "SameResourceRecordSignature" are flushed
830
831// SameResourceRecordNameClassInterface is functionally the same as SameResourceRecordSignature, except rrtype does not have to match
832
833#define SameResourceRecordSignature(A,B) (A)->resrec.rrtype == (B)->resrec.rrtype && SameResourceRecordNameClassInterface((A),(B))
834
835mDNSlocal mDNSBool SameResourceRecordNameClassInterface(const AuthRecord *const r1, const AuthRecord *const r2)
836{
837 if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse); }
838 if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse); }
839 if (r1->resrec.InterfaceID &&
840 r2->resrec.InterfaceID &&
841 r1->resrec.InterfaceID != r2->resrec.InterfaceID) return(mDNSfalse);
842 return (mDNSBool)(
843 r1->resrec.rrclass == r2->resrec.rrclass &&
844 r1->resrec.namehash == r2->resrec.namehash &&
845 SameDomainName(r1->resrec.name, r2->resrec.name));
846}
847
848// PacketRRMatchesSignature behaves as SameResourceRecordSignature, except that types may differ if our
849// authoratative record is unique (as opposed to shared). For unique records, we are supposed to have
850// complete ownership of *all* types for this name, so *any* record type with the same name is a conflict.
851// In addition, when probing we send our questions with the wildcard type kDNSQType_ANY,
852// so a response of any type should match, even if it is not actually the type the client plans to use.
853
854// For now, to make it easier to avoid false conflicts, we treat SPS Proxy records like shared records,
855// and require the rrtypes to match for the rdata to be considered potentially conflicting
856mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr)
857{
858 if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse); }
859 if (!authrr) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL"); return(mDNSfalse); }
860 if (pktrr->resrec.InterfaceID &&
861 authrr->resrec.InterfaceID &&
862 pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse);
863 if (!(authrr->resrec.RecordType & kDNSRecordTypeUniqueMask) || authrr->WakeUp.HMAC.l[0])
864 if (pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse);
865 if ((authrr->resrec.InterfaceID == mDNSInterface_Any) &&
866 !mDNSPlatformValidRecordForInterface(authrr, pktrr->resrec.InterfaceID)) return(mDNSfalse);
867 return (mDNSBool)(
868 pktrr->resrec.rrclass == authrr->resrec.rrclass &&
869 pktrr->resrec.namehash == authrr->resrec.namehash &&
870 SameDomainName(pktrr->resrec.name, authrr->resrec.name));
871}
872
873// CacheRecord *ka is the CacheRecord from the known answer list in the query.
874// This is the information that the requester believes to be correct.
875// AuthRecord *rr is the answer we are proposing to give, if not suppressed.
876// This is the information that we believe to be correct.
877// We've already determined that we plan to give this answer on this interface
878// (either the record is non-specific, or it is specific to this interface)
879// so now we just need to check the name, type, class, rdata and TTL.
880mDNSlocal mDNSBool ShouldSuppressKnownAnswer(const CacheRecord *const ka, const AuthRecord *const rr)
881{
882 // If RR signature is different, or data is different, then don't suppress our answer
883 if (!IdenticalResourceRecord(&ka->resrec, &rr->resrec)) return(mDNSfalse);
884
885 // If the requester's indicated TTL is less than half the real TTL,
886 // we need to give our answer before the requester's copy expires.
887 // If the requester's indicated TTL is at least half the real TTL,
888 // then we can suppress our answer this time.
889 // If the requester's indicated TTL is greater than the TTL we believe,
890 // then that's okay, and we don't need to do anything about it.
891 // (If two responders on the network are offering the same information,
892 // that's okay, and if they are offering the information with different TTLs,
893 // the one offering the lower TTL should defer to the one offering the higher TTL.)
894 return (mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2);
895}
896
897mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr)
898{
899 if (rr->resrec.RecordType == kDNSRecordTypeUnique)
900 {
901 if ((rr->LastAPTime + rr->ThisAPInterval) - m->timenow > mDNSPlatformOneSecond * 10)
902 {
903 LogMsg("SetNextAnnounceProbeTime: ProbeCount %d Next in %d %s", rr->ProbeCount, (rr->LastAPTime + rr->ThisAPInterval) - m->timenow, ARDisplayString(m, rr));
904 LogMsg("SetNextAnnounceProbeTime: m->SuppressProbes %d m->timenow %d diff %d", m->SuppressProbes, m->timenow, m->SuppressProbes - m->timenow);
905 }
906 if (m->NextScheduledProbe - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
907 m->NextScheduledProbe = (rr->LastAPTime + rr->ThisAPInterval);
908 // Some defensive code:
909 // If (rr->LastAPTime + rr->ThisAPInterval) happens to be far in the past, we don't want to allow
910 // NextScheduledProbe to be set excessively in the past, because that can cause bad things to happen.
911 // See: <rdar://problem/7795434> mDNS: Sometimes advertising stops working and record interval is set to zero
912 if (m->NextScheduledProbe - m->timenow < 0)
913 m->NextScheduledProbe = m->timenow;
914 }
915 else if (rr->AnnounceCount && (ResourceRecordIsValidAnswer(rr) || rr->resrec.RecordType == kDNSRecordTypeDeregistering))
916 {
917 if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
918 m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval);
919 }
920}
921
922mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr)
923{
924 // For reverse-mapping Sleep Proxy PTR records, probe interval is one second
925 rr->ThisAPInterval = rr->AddressProxy.type ? mDNSPlatformOneSecond : DefaultAPIntervalForRecordType(rr->resrec.RecordType);
926
927 // * If this is a record type that's going to probe, then we use the m->SuppressProbes time.
928 // * Otherwise, if it's not going to probe, but m->SuppressProbes is set because we have other
929 // records that are going to probe, then we delay its first announcement so that it will
930 // go out synchronized with the first announcement for the other records that *are* probing.
931 // This is a minor performance tweak that helps keep groups of related records synchronized together.
932 // The addition of "interval / 2" is to make sure that, in the event that any of the probes are
933 // delayed by a few milliseconds, this announcement does not inadvertently go out *before* the probing is complete.
934 // When the probing is complete and those records begin to announce, these records will also be picked up and accelerated,
935 // because they will meet the criterion of being at least half-way to their scheduled announcement time.
936 // * If it's not going to probe and m->SuppressProbes is not already set then we should announce immediately.
937
938 if (rr->ProbeCount)
939 {
940 // If we have no probe suppression time set, or it is in the past, set it now
941 if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0)
942 {
943 // To allow us to aggregate probes when a group of services are registered together,
944 // the first probe is delayed by a random delay in the range 1/8 to 1/4 second.
945 // This means the common-case behaviour is:
946 // randomized wait; probe
947 // 1/4 second wait; probe
948 // 1/4 second wait; probe
949 // 1/4 second wait; announce (i.e. service is normally announced 7/8 to 1 second after being registered)
950 m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2));
951
952 // If we already have a *probe* scheduled to go out sooner, then use that time to get better aggregation
953 if (m->SuppressProbes - m->NextScheduledProbe >= 0)
954 m->SuppressProbes = NonZeroTime(m->NextScheduledProbe);
955 if (m->SuppressProbes - m->timenow < 0) // Make sure we don't set m->SuppressProbes excessively in the past
956 m->SuppressProbes = m->timenow;
957
958 // If we already have a *query* scheduled to go out sooner, then use that time to get better aggregation
959 if (m->SuppressProbes - m->NextScheduledQuery >= 0)
960 m->SuppressProbes = NonZeroTime(m->NextScheduledQuery);
961 if (m->SuppressProbes - m->timenow < 0) // Make sure we don't set m->SuppressProbes excessively in the past
962 m->SuppressProbes = m->timenow;
963
964 // except... don't expect to be able to send before the m->SuppressSending timer fires
965 if (m->SuppressSending && m->SuppressProbes - m->SuppressSending < 0)
966 m->SuppressProbes = NonZeroTime(m->SuppressSending);
967
968 if (m->SuppressProbes - m->timenow > mDNSPlatformOneSecond * 8)
969 {
970 LogMsg("InitializeLastAPTime ERROR m->SuppressProbes %d m->NextScheduledProbe %d m->NextScheduledQuery %d m->SuppressSending %d %d",
971 m->SuppressProbes - m->timenow,
972 m->NextScheduledProbe - m->timenow,
973 m->NextScheduledQuery - m->timenow,
974 m->SuppressSending,
975 m->SuppressSending - m->timenow);
976 m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2));
977 }
978 }
979 rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval;
980 }
981 // Skip kDNSRecordTypeKnownUnique and kDNSRecordTypeShared records here and set their LastAPTime in the "else" block below so
982 // that they get announced immediately, otherwise, their announcement would be delayed until the based on the SuppressProbes value.
983 else if ((rr->resrec.RecordType != kDNSRecordTypeKnownUnique) && (rr->resrec.RecordType != kDNSRecordTypeShared) && m->SuppressProbes && (m->SuppressProbes - m->timenow >= 0))
984 rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval + DefaultProbeIntervalForTypeUnique * DefaultProbeCountForTypeUnique + rr->ThisAPInterval / 2;
985 else
986 rr->LastAPTime = m->timenow - rr->ThisAPInterval;
987
988 // For reverse-mapping Sleep Proxy PTR records we don't want to start probing instantly -- we
989 // wait one second to give the client a chance to go to sleep, and then start our ARP/NDP probing.
990 // After three probes one second apart with no answer, we conclude the client is now sleeping
991 // and we can begin broadcasting our announcements to take over ownership of that IP address.
992 // If we don't wait for the client to go to sleep, then when the client sees our ARP Announcements there's a risk
993 // (depending on the OS and networking stack it's using) that it might interpret it as a conflict and change its IP address.
994 if (rr->AddressProxy.type)
995 rr->LastAPTime = m->timenow;
996
997 // Set LastMCTime to now, to inhibit multicast responses
998 // (no need to send additional multicast responses when we're announcing anyway)
999 rr->LastMCTime = m->timenow;
1000 rr->LastMCInterface = mDNSInterfaceMark;
1001
1002 SetNextAnnounceProbeTime(m, rr);
1003}
1004
1005mDNSlocal const domainname *SetUnicastTargetToHostName(mDNS *const m, AuthRecord *rr)
1006{
1007 const domainname *target;
1008 if (rr->AutoTarget)
1009 {
1010 // For autotunnel services pointing at our IPv6 ULA we don't need or want a NAT mapping, but for all other
1011 // advertised services referencing our uDNS hostname, we want NAT mappings automatically created as appropriate,
1012 // with the port number in our advertised SRV record automatically tracking the external mapped port.
1013 DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name);
1014 if (!AuthInfo || !AuthInfo->AutoTunnel) rr->AutoTarget = Target_AutoHostAndNATMAP;
1015 }
1016
1017 target = GetServiceTarget(m, rr);
1018 if (!target || target->c[0] == 0)
1019 {
1020 // defer registration until we've got a target
1021 LogInfo("SetUnicastTargetToHostName No target for %s", ARDisplayString(m, rr));
1022 rr->state = regState_NoTarget;
1023 return mDNSNULL;
1024 }
1025 else
1026 {
1027 LogInfo("SetUnicastTargetToHostName target %##s for resource record %s", target->c, ARDisplayString(m,rr));
1028 return target;
1029 }
1030}
1031
1032// Right now this only applies to mDNS (.local) services where the target host is always m->MulticastHostname
1033// Eventually we should unify this with GetServiceTarget() in uDNS.c
1034mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr)
1035{
1036 domainname *const target = GetRRDomainNameTarget(&rr->resrec);
1037 const domainname *newname = &m->MulticastHostname;
1038
1039 if (!target) LogInfo("SetTargetToHostName: Don't know how to set the target of rrtype %s", DNSTypeName(rr->resrec.rrtype));
1040
1041 if (!(rr->ForceMCast || rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P || IsLocalDomain(&rr->namestorage)))
1042 {
1043 const domainname *const n = SetUnicastTargetToHostName(m, rr);
1044 if (n) newname = n;
1045 else { if (target) target->c[0] = 0; SetNewRData(&rr->resrec, mDNSNULL, 0); return; }
1046 }
1047
1048 if (target && SameDomainName(target, newname))
1049 debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name->c, target->c);
1050
1051 if (target && !SameDomainName(target, newname))
1052 {
1053 AssignDomainName(target, newname);
1054 SetNewRData(&rr->resrec, mDNSNULL, 0); // Update rdlength, rdestimate, rdatahash
1055
1056 // If we're in the middle of probing this record, we need to start again,
1057 // because changing its rdata may change the outcome of the tie-breaker.
1058 // (If the record type is kDNSRecordTypeUnique (unconfirmed unique) then DefaultProbeCountForRecordType is non-zero.)
1059 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
1060
1061 // If we've announced this record, we really should send a goodbye packet for the old rdata before
1062 // changing to the new rdata. However, in practice, we only do SetTargetToHostName for unique records,
1063 // so when we announce them we'll set the kDNSClass_UniqueRRSet and clear any stale data that way.
1064 if (rr->RequireGoodbye && rr->resrec.RecordType == kDNSRecordTypeShared)
1065 debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating",
1066 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1067
1068 rr->AnnounceCount = InitialAnnounceCount;
1069 rr->RequireGoodbye = mDNSfalse;
1070 rr->ProbeRestartCount = 0;
1071 InitializeLastAPTime(m, rr);
1072 }
1073}
1074
1075mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr)
1076{
1077 if (rr->RecordCallback)
1078 {
1079 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
1080 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
1081 rr->Acknowledged = mDNStrue;
1082 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
1083 rr->RecordCallback(m, rr, mStatus_NoError);
1084 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
1085 }
1086}
1087
1088mDNSexport void ActivateUnicastRegistration(mDNS *const m, AuthRecord *const rr)
1089{
1090 // Make sure that we don't activate the SRV record and associated service records, if it is in
1091 // NoTarget state. First time when a service is being instantiated, SRV record may be in NoTarget state.
1092 // We should not activate any of the other reords (PTR, TXT) that are part of the service. When
1093 // the target becomes available, the records will be reregistered.
1094 if (rr->resrec.rrtype != kDNSType_SRV)
1095 {
1096 AuthRecord *srvRR = mDNSNULL;
1097 if (rr->resrec.rrtype == kDNSType_PTR)
1098 srvRR = rr->Additional1;
1099 else if (rr->resrec.rrtype == kDNSType_TXT)
1100 srvRR = rr->DependentOn;
1101 if (srvRR)
1102 {
1103 if (srvRR->resrec.rrtype != kDNSType_SRV)
1104 {
1105 LogMsg("ActivateUnicastRegistration: ERROR!! Resource record %s wrong, expecting SRV type", ARDisplayString(m, srvRR));
1106 }
1107 else
1108 {
1109 LogInfo("ActivateUnicastRegistration: Found Service Record %s in state %d for %##s (%s)",
1110 ARDisplayString(m, srvRR), srvRR->state, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1111 rr->state = srvRR->state;
1112 }
1113 }
1114 }
1115
1116 if (rr->state == regState_NoTarget)
1117 {
1118 LogInfo("ActivateUnicastRegistration record %s in regState_NoTarget, not activating", ARDisplayString(m, rr));
1119 return;
1120 }
1121 // When we wake up from sleep, we call ActivateUnicastRegistration. It is possible that just before we went to sleep,
1122 // the service/record was being deregistered. In that case, we should not try to register again. For the cases where
1123 // the records are deregistered due to e.g., no target for the SRV record, we would have returned from above if it
1124 // was already in NoTarget state. If it was in the process of deregistration but did not complete fully before we went
1125 // to sleep, then it is okay to start in Pending state as we will go back to NoTarget state if we don't have a target.
1126 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
1127 {
1128 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to DeregPending", ARDisplayString(m, rr), rr->state);
1129 rr->state = regState_DeregPending;
1130 }
1131 else
1132 {
1133 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to Pending", ARDisplayString(m, rr), rr->state);
1134 rr->state = regState_Pending;
1135 }
1136 rr->ProbeCount = 0;
1137 rr->ProbeRestartCount = 0;
1138 rr->AnnounceCount = 0;
1139 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL;
1140 rr->LastAPTime = m->timenow - rr->ThisAPInterval;
1141 rr->expire = 0; // Forget about all the leases, start fresh
1142 rr->uselease = mDNStrue;
1143 rr->updateid = zeroID;
1144 rr->SRVChanged = mDNSfalse;
1145 rr->updateError = mStatus_NoError;
1146 // RestartRecordGetZoneData calls this function whenever a new interface gets registered with core.
1147 // The records might already be registered with the server and hence could have NAT state.
1148 if (rr->NATinfo.clientContext)
1149 {
1150 mDNS_StopNATOperation_internal(m, &rr->NATinfo);
1151 rr->NATinfo.clientContext = mDNSNULL;
1152 }
1153 if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; }
1154 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
1155 if (m->NextuDNSEvent - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
1156 m->NextuDNSEvent = (rr->LastAPTime + rr->ThisAPInterval);
1157}
1158
1159// Two records qualify to be local duplicates if:
1160// (a) the RecordTypes are the same, or
1161// (b) one is Unique and the other Verified
1162// (c) either is in the process of deregistering
1163#define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || \
1164 ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified) || \
1165 ((A)->resrec.RecordType == kDNSRecordTypeDeregistering || (B)->resrec.RecordType == kDNSRecordTypeDeregistering))
1166
1167#define RecordIsLocalDuplicate(A,B) \
1168 ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(& (A)->resrec, & (B)->resrec))
1169
1170mDNSlocal AuthRecord *CheckAuthIdenticalRecord(AuthHash *r, AuthRecord *rr)
1171{
1172 const AuthGroup *a;
1173 AuthRecord *rp;
1174
1175 a = AuthGroupForRecord(r, &rr->resrec);
1176 if (!a) return mDNSNULL;
1177 rp = a->members;
1178 while (rp)
1179 {
1180 if (!RecordIsLocalDuplicate(rp, rr))
1181 rp = rp->next;
1182 else
1183 {
1184 if (rp->resrec.RecordType == kDNSRecordTypeDeregistering)
1185 {
1186 rp->AnnounceCount = 0;
1187 rp = rp->next;
1188 }
1189 else return rp;
1190 }
1191 }
1192 return (mDNSNULL);
1193}
1194
1195mDNSlocal mDNSBool CheckAuthRecordConflict(AuthHash *r, AuthRecord *rr)
1196{
1197 const AuthGroup *a;
1198 const AuthRecord *rp;
1199
1200 a = AuthGroupForRecord(r, &rr->resrec);
1201 if (!a) return mDNSfalse;
1202 rp = a->members;
1203 while (rp)
1204 {
1205 const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr;
1206 const AuthRecord *s2 = rp->RRSet ? rp->RRSet : rp;
1207 if (s1 != s2 && SameResourceRecordSignature(rp, rr) && !IdenticalSameNameRecord(&rp->resrec, &rr->resrec))
1208 return mDNStrue;
1209 else
1210 rp = rp->next;
1211 }
1212 return (mDNSfalse);
1213}
1214
1215// checks to see if "rr" is already present
1216mDNSlocal AuthRecord *CheckAuthSameRecord(AuthHash *r, AuthRecord *rr)
1217{
1218 const AuthGroup *a;
1219 AuthRecord *rp;
1220
1221 a = AuthGroupForRecord(r, &rr->resrec);
1222 if (!a) return mDNSNULL;
1223 rp = a->members;
1224 while (rp)
1225 {
1226 if (rp != rr)
1227 rp = rp->next;
1228 else
1229 {
1230 return rp;
1231 }
1232 }
1233 return (mDNSNULL);
1234}
1235
1236
1237mDNSlocal void DecrementAutoTargetServices(mDNS *const m, AuthRecord *const rr)
1238{
1239 if (RRLocalOnly(rr))
1240 {
1241 // A sanity check, this should be prevented in calling code.
1242 LogInfo("DecrementAutoTargetServices: called for RRLocalOnly() record: %s", ARDisplayString(m, rr));
1243 return;
1244 }
1245
1246 if (!AuthRecord_uDNS(rr) && rr->resrec.rrtype == kDNSType_SRV && rr->AutoTarget == Target_AutoHost)
1247 {
1248 // If about to get rid of the last advertised service
1249 if (m->AutoTargetServices == 1)
1250 DeadvertiseAllInterfaceRecords(m);
1251
1252 m->AutoTargetServices--;
1253 LogInfo("DecrementAutoTargetServices: AutoTargetServices %d Record %s", m->AutoTargetServices, ARDisplayString(m, rr));
1254 }
1255
1256#if BONJOUR_ON_DEMAND
1257 if (!AuthRecord_uDNS(rr))
1258 {
1259 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1)
1260 m->NextBonjourDisableTime = NonZeroTime(m->timenow + (BONJOUR_DISABLE_DELAY * mDNSPlatformOneSecond));
1261 m->NumAllInterfaceRecords--;
1262 LogInfo("DecrementAutoTargetServices: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %s",
1263 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, ARDisplayString(m, rr));
1264 }
1265#endif // BONJOUR_ON_DEMAND
1266}
1267
1268mDNSlocal void IncrementAutoTargetServices(mDNS *const m, AuthRecord *const rr)
1269{
1270 mDNSBool enablingBonjour = 0;
1271
1272 if (RRLocalOnly(rr))
1273 {
1274 // A sanity check, this should be prevented in calling code.
1275 LogInfo("IncrementAutoTargetServices: called for RRLocalOnly() record: %s", ARDisplayString(m, rr));
1276 return;
1277 }
1278
1279#if BONJOUR_ON_DEMAND
1280 if (!AuthRecord_uDNS(rr))
1281 {
1282 m->NumAllInterfaceRecords++;
1283 LogInfo("IncrementAutoTargetServices: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %s",
1284 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, ARDisplayString(m, rr));
1285 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1)
1286 {
1287 m->NextBonjourDisableTime = 0;
1288 if (m->BonjourEnabled == 0)
1289 {
1290 // Enable Bonjour immediately by scheduling network changed processing where
1291 // we will join the multicast group on each active interface.
1292 m->BonjourEnabled = 1;
1293 enablingBonjour = 1;
1294 m->NetworkChanged = m->timenow;
1295 }
1296 }
1297 }
1298#endif // BONJOUR_ON_DEMAND
1299
1300 if (!AuthRecord_uDNS(rr) && rr->resrec.rrtype == kDNSType_SRV && rr->AutoTarget == Target_AutoHost)
1301 {
1302 m->AutoTargetServices++;
1303 LogInfo("IncrementAutoTargetServices: AutoTargetServices %d Record %s", m->AutoTargetServices, ARDisplayString(m, rr));
1304
1305 // If this is the first advertised service and we did not just enable Bonjour above, then
1306 // advertise all the interface records. If we did enable Bonjour above, the interface records will
1307 // be advertised during the network changed processing scheduled above, so no need
1308 // to do it here.
1309 if ((m->AutoTargetServices == 1) && (enablingBonjour == 0))
1310 AdvertiseAllInterfaceRecords(m);
1311 }
1312}
1313
1314mDNSlocal void getKeepaliveRaddr(mDNS *const m, AuthRecord *rr, mDNSAddr *raddr)
1315{
1316 mDNSAddr laddr = zeroAddr;
1317 mDNSEthAddr eth = zeroEthAddr;
1318 mDNSIPPort lport = zeroIPPort;
1319 mDNSIPPort rport = zeroIPPort;
1320 mDNSu32 timeout = 0;
1321 mDNSu32 seq = 0;
1322 mDNSu32 ack = 0;
1323 mDNSu16 win = 0;
1324
1325 if (mDNS_KeepaliveRecord(&rr->resrec))
1326 {
1327 mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, raddr, &eth, &seq, &ack, &lport, &rport, &win);
1328 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(raddr) || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport))
1329 {
1330 LogMsg("getKeepaliveRaddr: not a valid record %s for keepalive %#a:%d %#a:%d", ARDisplayString(m, rr), &laddr, lport.NotAnInteger, raddr, rport.NotAnInteger);
1331 return;
1332 }
1333 }
1334}
1335
1336// Exported so uDNS.c can call this
1337mDNSexport mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr)
1338{
1339 domainname *target = GetRRDomainNameTarget(&rr->resrec);
1340 AuthRecord *r;
1341 AuthRecord **p = &m->ResourceRecords;
1342 AuthRecord **d = &m->DuplicateRecords;
1343
1344 if ((mDNSs32)rr->resrec.rroriginalttl <= 0)
1345 { LogMsg("mDNS_Register_internal: TTL %X should be 1 - 0x7FFFFFFF %s", rr->resrec.rroriginalttl, ARDisplayString(m, rr)); return(mStatus_BadParamErr); }
1346
1347 if (!rr->resrec.RecordType)
1348 { LogMsg("mDNS_Register_internal: RecordType must be non-zero %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); }
1349
1350 if (m->ShutdownTime)
1351 { LogMsg("mDNS_Register_internal: Shutting down, can't register %s", ARDisplayString(m, rr)); return(mStatus_ServiceNotRunning); }
1352
1353 if (m->DivertMulticastAdvertisements && !AuthRecord_uDNS(rr))
1354 {
1355 mDNSInterfaceID previousID = rr->resrec.InterfaceID;
1356 if (rr->resrec.InterfaceID == mDNSInterface_Any || rr->resrec.InterfaceID == mDNSInterface_P2P)
1357 {
1358 rr->resrec.InterfaceID = mDNSInterface_LocalOnly;
1359 rr->ARType = AuthRecordLocalOnly;
1360 }
1361 if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly)
1362 {
1363 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID);
1364 if (intf && !intf->Advertise) { rr->resrec.InterfaceID = mDNSInterface_LocalOnly; rr->ARType = AuthRecordLocalOnly; }
1365 }
1366 if (rr->resrec.InterfaceID != previousID)
1367 LogInfo("mDNS_Register_internal: Diverting record to local-only %s", ARDisplayString(m, rr));
1368 }
1369
1370 if (RRLocalOnly(rr))
1371 {
1372 if (CheckAuthSameRecord(&m->rrauth, rr))
1373 {
1374 LogMsg("mDNS_Register_internal: ERROR!! Tried to register LocalOnly AuthRecord %p %##s (%s) that's already in the list",
1375 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1376 return(mStatus_AlreadyRegistered);
1377 }
1378 }
1379 else
1380 {
1381 while (*p && *p != rr) p=&(*p)->next;
1382 if (*p)
1383 {
1384 LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the list",
1385 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1386 return(mStatus_AlreadyRegistered);
1387 }
1388 }
1389
1390 while (*d && *d != rr) d=&(*d)->next;
1391 if (*d)
1392 {
1393 LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the Duplicate list",
1394 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1395 return(mStatus_AlreadyRegistered);
1396 }
1397
1398 if (rr->DependentOn)
1399 {
1400 if (rr->resrec.RecordType == kDNSRecordTypeUnique)
1401 rr->resrec.RecordType = kDNSRecordTypeVerified;
1402 else if (rr->resrec.RecordType != kDNSRecordTypeKnownUnique)
1403 {
1404 LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique or kDNSRecordTypeKnownUnique",
1405 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1406 return(mStatus_Invalid);
1407 }
1408 if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique)))
1409 {
1410 LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X",
1411 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType);
1412 return(mStatus_Invalid);
1413 }
1414 }
1415
1416 rr->next = mDNSNULL;
1417
1418 // Field Group 1: The actual information pertaining to this resource record
1419 // Set up by client prior to call
1420
1421 // Field Group 2: Persistent metadata for Authoritative Records
1422// rr->Additional1 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1423// rr->Additional2 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1424// rr->DependentOn = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1425// rr->RRSet = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1426// rr->Callback = already set in mDNS_SetupResourceRecord
1427// rr->Context = already set in mDNS_SetupResourceRecord
1428// rr->RecordType = already set in mDNS_SetupResourceRecord
1429// rr->HostTarget = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client
1430// rr->AllowRemoteQuery = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client
1431 // Make sure target is not uninitialized data, or we may crash writing debugging log messages
1432 if (rr->AutoTarget && target) target->c[0] = 0;
1433
1434 // Field Group 3: Transient state for Authoritative Records
1435 rr->Acknowledged = mDNSfalse;
1436 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
1437 rr->ProbeRestartCount = 0;
1438 rr->AnnounceCount = InitialAnnounceCount;
1439 rr->RequireGoodbye = mDNSfalse;
1440 rr->AnsweredLocalQ = mDNSfalse;
1441 rr->IncludeInProbe = mDNSfalse;
1442 rr->ImmedUnicast = mDNSfalse;
1443 rr->SendNSECNow = mDNSNULL;
1444 rr->ImmedAnswer = mDNSNULL;
1445 rr->ImmedAdditional = mDNSNULL;
1446 rr->SendRNow = mDNSNULL;
1447 rr->v4Requester = zerov4Addr;
1448 rr->v6Requester = zerov6Addr;
1449 rr->NextResponse = mDNSNULL;
1450 rr->NR_AnswerTo = mDNSNULL;
1451 rr->NR_AdditionalTo = mDNSNULL;
1452 if (!rr->AutoTarget) InitializeLastAPTime(m, rr);
1453// rr->LastAPTime = Set for us in InitializeLastAPTime()
1454// rr->LastMCTime = Set for us in InitializeLastAPTime()
1455// rr->LastMCInterface = Set for us in InitializeLastAPTime()
1456 rr->NewRData = mDNSNULL;
1457 rr->newrdlength = 0;
1458 rr->UpdateCallback = mDNSNULL;
1459 rr->UpdateCredits = kMaxUpdateCredits;
1460 rr->NextUpdateCredit = 0;
1461 rr->UpdateBlocked = 0;
1462
1463 // For records we're holding as proxy (except reverse-mapping PTR records) two announcements is sufficient
1464 if (rr->WakeUp.HMAC.l[0] && !rr->AddressProxy.type) rr->AnnounceCount = 2;
1465
1466 // Field Group 4: Transient uDNS state for Authoritative Records
1467 rr->state = regState_Zero;
1468 rr->uselease = 0;
1469 rr->expire = 0;
1470 rr->Private = 0;
1471 rr->updateid = zeroID;
1472 rr->updateIntID = zeroOpaque64;
1473 rr->zone = rr->resrec.name;
1474 rr->nta = mDNSNULL;
1475 rr->tcp = mDNSNULL;
1476 rr->OrigRData = 0;
1477 rr->OrigRDLen = 0;
1478 rr->InFlightRData = 0;
1479 rr->InFlightRDLen = 0;
1480 rr->QueuedRData = 0;
1481 rr->QueuedRDLen = 0;
1482 //mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo));
1483 // We should be recording the actual internal port for this service record here. Once we initiate our NAT mapping
1484 // request we'll subsequently overwrite srv.port with the allocated external NAT port -- potentially multiple
1485 // times with different values if the external NAT port changes during the lifetime of the service registration.
1486 //if (rr->resrec.rrtype == kDNSType_SRV) rr->NATinfo.IntPort = rr->resrec.rdata->u.srv.port;
1487
1488// rr->resrec.interface = already set in mDNS_SetupResourceRecord
1489// rr->resrec.name->c = MUST be set by client
1490// rr->resrec.rrtype = already set in mDNS_SetupResourceRecord
1491// rr->resrec.rrclass = already set in mDNS_SetupResourceRecord
1492// rr->resrec.rroriginalttl = already set in mDNS_SetupResourceRecord
1493// rr->resrec.rdata = MUST be set by client, unless record type is CNAME or PTR and rr->HostTarget is set
1494
1495 // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,
1496 // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".
1497 // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.
1498 if (rr->resrec.rrtype == kDNSType_TXT && rr->resrec.rdlength == 0) { rr->resrec.rdlength = 1; rr->resrec.rdata->u.txt.c[0] = 0; }
1499
1500 if (rr->AutoTarget)
1501 {
1502 SetTargetToHostName(m, rr); // Also sets rdlength and rdestimate for us, and calls InitializeLastAPTime();
1503#ifndef UNICAST_DISABLED
1504 // If we have no target record yet, SetTargetToHostName will set rr->state == regState_NoTarget
1505 // In this case we leave the record half-formed in the list, and later we'll remove it from the list and re-add it properly.
1506 if (rr->state == regState_NoTarget)
1507 {
1508 // Initialize the target so that we don't crash while logging etc.
1509 domainname *tar = GetRRDomainNameTarget(&rr->resrec);
1510 if (tar) tar->c[0] = 0;
1511 LogInfo("mDNS_Register_internal: record %s in NoTarget state", ARDisplayString(m, rr));
1512 }
1513#endif
1514 }
1515 else
1516 {
1517 rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse);
1518 rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue);
1519 }
1520
1521 if (!ValidateDomainName(rr->resrec.name))
1522 { LogMsg("Attempt to register record with invalid name: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }
1523
1524 // Don't do this until *after* we've set rr->resrec.rdlength
1525 if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata))
1526 { LogMsg("Attempt to register record with invalid rdata: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }
1527
1528 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
1529 rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(&rr->resrec);
1530
1531 if (RRLocalOnly(rr))
1532 {
1533 // If this is supposed to be unique, make sure we don't have any name conflicts.
1534 // If we found a conflict, we may still want to insert the record in the list but mark it appropriately
1535 // (kDNSRecordTypeDeregistering) so that we deliver RMV events to the application. But this causes more
1536 // complications and not clear whether there are any benefits. See rdar:9304275 for details.
1537 // Hence, just bail out.
1538 // This comment is doesn’t make any sense. -- SC
1539 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
1540 {
1541 if (CheckAuthRecordConflict(&m->rrauth, rr))
1542 {
1543 LogInfo("mDNS_Register_internal: Name conflict %s (%p), InterfaceID %p", ARDisplayString(m, rr), rr, rr->resrec.InterfaceID);
1544 return mStatus_NameConflict;
1545 }
1546 }
1547 }
1548
1549 // For uDNS records, we don't support duplicate checks at this time.
1550#ifndef UNICAST_DISABLED
1551 if (AuthRecord_uDNS(rr))
1552 {
1553 if (!m->NewLocalRecords) m->NewLocalRecords = rr;
1554 // When we called SetTargetToHostName, it may have caused mDNS_Register_internal to be re-entered, appending new
1555 // records to the list, so we now need to update p to advance to the new end to the list before appending our new record.
1556 // Note that for AutoTunnel this should never happen, but this check makes the code future-proof.
1557 while (*p) p=&(*p)->next;
1558 *p = rr;
1559 if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
1560 rr->ProbeCount = 0;
1561 rr->ProbeRestartCount = 0;
1562 rr->AnnounceCount = 0;
1563 if (rr->state != regState_NoTarget) ActivateUnicastRegistration(m, rr);
1564 return(mStatus_NoError); // <--- Note: For unicast records, code currently bails out at this point
1565 }
1566#endif
1567
1568 // Now that we've finished building our new record, make sure it's not identical to one we already have
1569 if (RRLocalOnly(rr))
1570 {
1571 rr->ProbeCount = 0;
1572 rr->ProbeRestartCount = 0;
1573 rr->AnnounceCount = 0;
1574 r = CheckAuthIdenticalRecord(&m->rrauth, rr);
1575 }
1576 else
1577 {
1578 for (r = m->ResourceRecords; r; r=r->next)
1579 if (RecordIsLocalDuplicate(r, rr))
1580 {
1581 if (r->resrec.RecordType == kDNSRecordTypeDeregistering) r->AnnounceCount = 0;
1582 else break;
1583 }
1584 }
1585
1586 if (r)
1587 {
1588 LogInfo("mDNS_Register_internal: Adding to duplicate list %s", ARDisplayString(m,rr));
1589 *d = rr;
1590 // If the previous copy of this record is already verified unique,
1591 // then indicate that we should move this record promptly to kDNSRecordTypeUnique state.
1592 // Setting ProbeCount to zero will cause SendQueries() to advance this record to
1593 // kDNSRecordTypeVerified state and call the client callback at the next appropriate time.
1594 if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)
1595 rr->ProbeCount = 0;
1596 }
1597 else
1598 {
1599 LogInfo("mDNS_Register_internal: Adding to active record list %s", ARDisplayString(m,rr));
1600 if (RRLocalOnly(rr))
1601 {
1602 AuthGroup *ag;
1603 ag = InsertAuthRecord(m, &m->rrauth, rr);
1604 if (ag && !ag->NewLocalOnlyRecords)
1605 {
1606 m->NewLocalOnlyRecords = mDNStrue;
1607 ag->NewLocalOnlyRecords = rr;
1608 }
1609 // No probing for LocalOnly records; acknowledge them right away
1610 if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
1611 AcknowledgeRecord(m, rr);
1612 return(mStatus_NoError);
1613 }
1614 else
1615 {
1616 if (!m->NewLocalRecords) m->NewLocalRecords = rr;
1617 *p = rr;
1618 }
1619 }
1620
1621 if (!AuthRecord_uDNS(rr)) // This check is superfluous, given that for unicast records we (currently) bail out above
1622 {
1623 // We have inserted the record in the list. See if we have to advertise the A/AAAA, HINFO, PTR records.
1624 IncrementAutoTargetServices(m, rr);
1625
1626 // For records that are not going to probe, acknowledge them right away
1627 if (rr->resrec.RecordType != kDNSRecordTypeUnique && rr->resrec.RecordType != kDNSRecordTypeDeregistering)
1628 AcknowledgeRecord(m, rr);
1629
1630 // Adding a record may affect whether or not we should sleep
1631 mDNS_UpdateAllowSleep(m);
1632 }
1633
1634 // If this is a non-sleep proxy keepalive record, fetch the MAC address of the remote host.
1635 // This is used by the in-NIC proxy to send the keepalive packets.
1636 if (!rr->WakeUp.HMAC.l[0] && mDNS_KeepaliveRecord(&rr->resrec))
1637 {
1638 mDNSAddr raddr;
1639 // Set the record type to known unique to prevent probing keep alive records.
1640 // Also make sure we do not announce the keepalive records.
1641 rr->resrec.RecordType = kDNSRecordTypeKnownUnique;
1642 rr->AnnounceCount = 0;
1643 getKeepaliveRaddr(m, rr, &raddr);
1644 // This is an asynchronous call. Once the remote MAC address is available, helper will schedule an
1645 // asynchronous task to update the resource record
1646 mDNSPlatformGetRemoteMacAddr(&raddr);
1647 }
1648
1649 return(mStatus_NoError);
1650}
1651
1652mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr)
1653{
1654 m->ProbeFailTime = m->timenow;
1655 m->NumFailedProbes++;
1656 // If we've had fifteen or more probe failures, rate-limit to one every five seconds.
1657 // If a bunch of hosts have all been configured with the same name, then they'll all
1658 // conflict and run through the same series of names: name-2, name-3, name-4, etc.,
1659 // up to name-10. After that they'll start adding random increments in the range 1-100,
1660 // so they're more likely to branch out in the available namespace and settle on a set of
1661 // unique names quickly. If after five more tries the host is still conflicting, then we
1662 // may have a serious problem, so we start rate-limiting so we don't melt down the network.
1663 if (m->NumFailedProbes >= 15)
1664 {
1665 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5);
1666 LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect",
1667 m->NumFailedProbes, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1668 }
1669}
1670
1671mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr)
1672{
1673 RData *OldRData = rr->resrec.rdata;
1674 mDNSu16 OldRDLen = rr->resrec.rdlength;
1675 SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata
1676 rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...
1677 if (rr->UpdateCallback)
1678 rr->UpdateCallback(m, rr, OldRData, OldRDLen); // ... and let the client know
1679}
1680
1681// Note: mDNS_Deregister_internal can call a user callback, which may change the record list and/or question list.
1682// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
1683// Exported so uDNS.c can call this
1684mDNSexport mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt)
1685{
1686 AuthRecord *r2;
1687 mDNSu8 RecordType = rr->resrec.RecordType;
1688 AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records
1689 mDNSBool dupList = mDNSfalse;
1690
1691 if (RRLocalOnly(rr))
1692 {
1693 AuthGroup *a;
1694 AuthRecord **rp;
1695
1696 a = AuthGroupForRecord(&m->rrauth, &rr->resrec);
1697 if (!a) return mDNSfalse;
1698 rp = &a->members;
1699 while (*rp && *rp != rr) rp=&(*rp)->next;
1700 p = rp;
1701 }
1702 else
1703 {
1704 while (*p && *p != rr) p=&(*p)->next;
1705 }
1706
1707 if (*p)
1708 {
1709 // We found our record on the main list. See if there are any duplicates that need special handling.
1710 if (drt == mDNS_Dereg_conflict) // If this was a conflict, see that all duplicates get the same treatment
1711 {
1712 // Scan for duplicates of rr, and mark them for deregistration at the end of this routine, after we've finished
1713 // deregistering rr. We need to do this scan *before* we give the client the chance to free and reuse the rr memory.
1714 for (r2 = m->DuplicateRecords; r2; r2=r2->next) if (RecordIsLocalDuplicate(r2, rr)) r2->ProbeCount = 0xFF;
1715 }
1716 else
1717 {
1718 // Before we delete the record (and potentially send a goodbye packet)
1719 // first see if we have a record on the duplicate list ready to take over from it.
1720 AuthRecord **d = &m->DuplicateRecords;
1721 while (*d && !RecordIsLocalDuplicate(*d, rr)) d=&(*d)->next;
1722 if (*d)
1723 {
1724 AuthRecord *dup = *d;
1725 debugf("mDNS_Register_internal: Duplicate record %p taking over from %p %##s (%s)",
1726 dup, rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1727 *d = dup->next; // Cut replacement record from DuplicateRecords list
1728 if (RRLocalOnly(rr))
1729 {
1730 dup->next = mDNSNULL;
1731 if (!InsertAuthRecord(m, &m->rrauth, dup)) LogMsg("mDNS_Deregister_internal: ERROR!! cannot insert %s", ARDisplayString(m, dup));
1732 }
1733 else
1734 {
1735 dup->next = rr->next; // And then...
1736 rr->next = dup; // ... splice it in right after the record we're about to delete
1737 }
1738 dup->resrec.RecordType = rr->resrec.RecordType;
1739 dup->ProbeCount = rr->ProbeCount;
1740 dup->ProbeRestartCount = rr->ProbeRestartCount;
1741 dup->AnnounceCount = rr->AnnounceCount;
1742 dup->RequireGoodbye = rr->RequireGoodbye;
1743 dup->AnsweredLocalQ = rr->AnsweredLocalQ;
1744 dup->ImmedAnswer = rr->ImmedAnswer;
1745 dup->ImmedUnicast = rr->ImmedUnicast;
1746 dup->ImmedAdditional = rr->ImmedAdditional;
1747 dup->v4Requester = rr->v4Requester;
1748 dup->v6Requester = rr->v6Requester;
1749 dup->ThisAPInterval = rr->ThisAPInterval;
1750 dup->LastAPTime = rr->LastAPTime;
1751 dup->LastMCTime = rr->LastMCTime;
1752 dup->LastMCInterface = rr->LastMCInterface;
1753 dup->Private = rr->Private;
1754 dup->state = rr->state;
1755 rr->RequireGoodbye = mDNSfalse;
1756 rr->AnsweredLocalQ = mDNSfalse;
1757 }
1758 }
1759 }
1760 else
1761 {
1762 // We didn't find our record on the main list; try the DuplicateRecords list instead.
1763 p = &m->DuplicateRecords;
1764 while (*p && *p != rr) p=&(*p)->next;
1765 // If we found our record on the duplicate list, then make sure we don't send a goodbye for it
1766 if (*p)
1767 {
1768 // Duplicate records are not used for sending wakeups or goodbyes. Hence, deregister them
1769 // immediately. When there is a conflict, we deregister all the conflicting duplicate records
1770 // also that have been marked above in this function. In that case, we come here and if we don't
1771 // deregister (unilink from the DuplicateRecords list), we will be recursing infinitely. Hence,
1772 // clear the HMAC which will cause it to deregister. See <rdar://problem/10380988> for
1773 // details.
1774 rr->WakeUp.HMAC = zeroEthAddr;
1775 rr->RequireGoodbye = mDNSfalse;
1776 rr->resrec.RecordType = kDNSRecordTypeDeregistering;
1777 dupList = mDNStrue;
1778 }
1779 if (*p) debugf("mDNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)",
1780 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1781 }
1782
1783 if (!*p)
1784 {
1785 // No need to log an error message if we already know this is a potentially repeated deregistration
1786 if (drt != mDNS_Dereg_repeat)
1787 LogMsg("mDNS_Deregister_internal: Record %p not found in list %s", rr, ARDisplayString(m,rr));
1788 return(mStatus_BadReferenceErr);
1789 }
1790
1791 // If this is a shared record and we've announced it at least once,
1792 // we need to retract that announcement before we delete the record
1793
1794 // If this is a record (including mDNSInterface_LocalOnly records) for which we've given local-only answers then
1795 // it's tempting to just do "AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse)" here, but that would not not be safe.
1796 // The AnswerAllLocalQuestionsWithLocalAuthRecord routine walks the question list invoking client callbacks, using the "m->CurrentQuestion"
1797 // mechanism to cope with the client callback modifying the question list while that's happening.
1798 // However, mDNS_Deregister could have been called from a client callback (e.g. from the domain enumeration callback FoundDomain)
1799 // which means that the "m->CurrentQuestion" mechanism is already in use to protect that list, so we can't use it twice.
1800 // More generally, if we invoke callbacks from within a client callback, then those callbacks could deregister other
1801 // records, thereby invoking yet more callbacks, without limit.
1802 // The solution is to defer delivering the "Remove" events until mDNS_Execute time, just like we do for sending
1803 // actual goodbye packets.
1804
1805#ifndef UNICAST_DISABLED
1806 if (AuthRecord_uDNS(rr))
1807 {
1808 if (rr->RequireGoodbye)
1809 {
1810 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
1811 rr->resrec.RecordType = kDNSRecordTypeDeregistering;
1812 m->LocalRemoveEvents = mDNStrue;
1813 uDNS_DeregisterRecord(m, rr);
1814 // At this point unconditionally we bail out
1815 // Either uDNS_DeregisterRecord will have completed synchronously, and called CompleteDeregistration,
1816 // which calls us back here with RequireGoodbye set to false, or it will have initiated the deregistration
1817 // process and will complete asynchronously. Either way we don't need to do anything more here.
1818 return(mStatus_NoError);
1819 }
1820 // Sometimes the records don't complete proper deregistration i.e., don't wait for a response
1821 // from the server. In that case, if the records have been part of a group update, clear the
1822 // state here. Some recors e.g., AutoTunnel gets reused without ever being completely initialized
1823 rr->updateid = zeroID;
1824
1825 // We defer cleaning up NAT state only after sending goodbyes. This is important because
1826 // RecordRegistrationGotZoneData guards against creating NAT state if clientContext is non-NULL.
1827 // This happens today when we turn on/off interface where we get multiple network transitions
1828 // and RestartRecordGetZoneData triggers re-registration of the resource records even though
1829 // they may be in Registered state which causes NAT information to be setup multiple times. Defering
1830 // the cleanup here keeps clientContext non-NULL and hence prevents that. Note that cleaning up
1831 // NAT state here takes care of the case where we did not send goodbyes at all.
1832 if (rr->NATinfo.clientContext)
1833 {
1834 mDNS_StopNATOperation_internal(m, &rr->NATinfo);
1835 rr->NATinfo.clientContext = mDNSNULL;
1836 }
1837 if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; }
1838 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
1839 }
1840#endif // UNICAST_DISABLED
1841
1842 if (RecordType == kDNSRecordTypeUnregistered)
1843 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered", ARDisplayString(m, rr));
1844 else if (RecordType == kDNSRecordTypeDeregistering)
1845 {
1846 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering", ARDisplayString(m, rr));
1847 return(mStatus_BadReferenceErr);
1848 }
1849
1850 // <rdar://problem/7457925> Local-only questions don't get remove events for unique records
1851 // We may want to consider changing this code so that we generate local-only question "rmv"
1852 // events (and maybe goodbye packets too) for unique records as well as for shared records
1853 // Note: If we change the logic for this "if" statement, need to ensure that the code in
1854 // CompleteDeregistration() sets the appropriate state variables to gaurantee that "else"
1855 // clause will execute here and the record will be cut from the list.
1856 if (rr->WakeUp.HMAC.l[0] ||
1857 (RecordType == kDNSRecordTypeShared && (rr->RequireGoodbye || rr->AnsweredLocalQ)))
1858 {
1859 verbosedebugf("mDNS_Deregister_internal: Starting deregistration for %s", ARDisplayString(m, rr));
1860 rr->resrec.RecordType = kDNSRecordTypeDeregistering;
1861 rr->resrec.rroriginalttl = 0;
1862 rr->AnnounceCount = rr->WakeUp.HMAC.l[0] ? WakeupCount : (drt == mDNS_Dereg_rapid) ? 1 : GoodbyeCount;
1863 rr->ThisAPInterval = mDNSPlatformOneSecond * 2;
1864 rr->LastAPTime = m->timenow - rr->ThisAPInterval;
1865 m->LocalRemoveEvents = mDNStrue;
1866 if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)
1867 m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);
1868 }
1869 else
1870 {
1871 if (!dupList && RRLocalOnly(rr))
1872 {
1873 AuthGroup *ag = RemoveAuthRecord(m, &m->rrauth, rr);
1874 if (ag->NewLocalOnlyRecords == rr) ag->NewLocalOnlyRecords = rr->next;
1875 }
1876 else
1877 {
1878 *p = rr->next; // Cut this record from the list
1879 if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next;
1880 DecrementAutoTargetServices(m, rr);
1881 }
1882 // If someone is about to look at this, bump the pointer forward
1883 if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
1884 rr->next = mDNSNULL;
1885
1886 // Should we generate local remove events here?
1887 // i.e. something like:
1888 // if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; }
1889
1890 verbosedebugf("mDNS_Deregister_internal: Deleting record for %s", ARDisplayString(m, rr));
1891 rr->resrec.RecordType = kDNSRecordTypeUnregistered;
1892
1893 if ((drt == mDNS_Dereg_conflict || drt == mDNS_Dereg_repeat) && RecordType == kDNSRecordTypeShared)
1894 debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)",
1895 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1896
1897 // If we have an update queued up which never executed, give the client a chance to free that memory
1898 if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client
1899
1900
1901 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
1902 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
1903 // In this case the likely client action to the mStatus_MemFree message is to free the memory,
1904 // so any attempt to touch rr after this is likely to lead to a crash.
1905 if (drt != mDNS_Dereg_conflict)
1906 {
1907 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
1908 LogInfo("mDNS_Deregister_internal: callback with mStatus_MemFree for %s", ARDisplayString(m, rr));
1909 if (rr->RecordCallback)
1910 rr->RecordCallback(m, rr, mStatus_MemFree); // MUST NOT touch rr after this
1911 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
1912 }
1913 else
1914 {
1915 RecordProbeFailure(m, rr);
1916 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
1917 if (rr->RecordCallback)
1918 rr->RecordCallback(m, rr, mStatus_NameConflict); // MUST NOT touch rr after this
1919 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
1920 // Now that we've finished deregistering rr, check our DuplicateRecords list for any that we marked previously.
1921 // Note that with all the client callbacks going on, by the time we get here all the
1922 // records we marked may have been explicitly deregistered by the client anyway.
1923 r2 = m->DuplicateRecords;
1924 while (r2)
1925 {
1926 if (r2->ProbeCount != 0xFF)
1927 {
1928 r2 = r2->next;
1929 }
1930 else
1931 {
1932#if APPLE_OSX_mDNSResponder
1933 // See if this record was also registered with any D2D plugins.
1934 D2D_stop_advertising_record(r2);
1935#endif
1936 mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict);
1937 // As this is a duplicate record, it will be unlinked from the list
1938 // immediately
1939 r2 = m->DuplicateRecords;
1940 }
1941 }
1942 }
1943 }
1944 mDNS_UpdateAllowSleep(m);
1945 return(mStatus_NoError);
1946}
1947
1948// ***************************************************************************
1949#if COMPILER_LIKES_PRAGMA_MARK
1950#pragma mark -
1951#pragma mark - Packet Sending Functions
1952#endif
1953
1954mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)
1955{
1956 if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)
1957 {
1958 **nrpp = rr;
1959 // NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo)
1960 // If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does
1961 // The referenced record will definitely be acceptable (by recursive application of this rule)
1962 if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo;
1963 rr->NR_AdditionalTo = add;
1964 *nrpp = &rr->NextResponse;
1965 }
1966 debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
1967}
1968
1969mDNSlocal void AddRRSetAdditionalsToResponseList(mDNS *const m, AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *additional, const mDNSInterfaceID InterfaceID)
1970{
1971 AuthRecord *rr2;
1972 if (additional->resrec.RecordType & kDNSRecordTypeUniqueMask)
1973 {
1974 for (rr2 = m->ResourceRecords; rr2; rr2 = rr2->next)
1975 {
1976 if ((rr2->resrec.namehash == additional->resrec.namehash) &&
1977 (rr2->resrec.rrtype == additional->resrec.rrtype) &&
1978 (rr2 != additional) &&
1979 (rr2->resrec.RecordType & kDNSRecordTypeUniqueMask) &&
1980 (rr2->resrec.rrclass == additional->resrec.rrclass) &&
1981 ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) &&
1982 SameDomainName(rr2->resrec.name, additional->resrec.name))
1983 {
1984 AddRecordToResponseList(nrpp, rr2, rr);
1985 }
1986 }
1987 }
1988}
1989
1990mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID)
1991{
1992 AuthRecord *rr, *rr2;
1993 for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put
1994 {
1995 // (Note: This is an "if", not a "while". If we add a record, we'll find it again
1996 // later in the "for" loop, and we will follow further "additional" links then.)
1997 if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))
1998 {
1999 AddRecordToResponseList(nrpp, rr->Additional1, rr);
2000 AddRRSetAdditionalsToResponseList(m, nrpp, rr, rr->Additional1, InterfaceID);
2001 }
2002
2003 if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))
2004 {
2005 AddRecordToResponseList(nrpp, rr->Additional2, rr);
2006 AddRRSetAdditionalsToResponseList(m, nrpp, rr, rr->Additional2, InterfaceID);
2007 }
2008
2009 // For SRV records, automatically add the Address record(s) for the target host
2010 if (rr->resrec.rrtype == kDNSType_SRV)
2011 {
2012 for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records
2013 if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ...
2014 ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ...
2015 rr->resrec.rdatahash == rr2->resrec.namehash && // ... whose name is the name of the SRV target
2016 SameDomainName(&rr->resrec.rdata->u.srv.target, rr2->resrec.name))
2017 AddRecordToResponseList(nrpp, rr2, rr);
2018 }
2019 else if (RRTypeIsAddressType(rr->resrec.rrtype)) // For A or AAAA, put counterpart as additional
2020 {
2021 for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records
2022 if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ...
2023 ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ...
2024 rr->resrec.namehash == rr2->resrec.namehash && // ... and have the same name
2025 SameDomainName(rr->resrec.name, rr2->resrec.name))
2026 AddRecordToResponseList(nrpp, rr2, rr);
2027 }
2028 else if (rr->resrec.rrtype == kDNSType_PTR) // For service PTR, see if we want to add DeviceInfo record
2029 {
2030 if (ResourceRecordIsValidInterfaceAnswer(&m->DeviceInfo, InterfaceID) &&
2031 SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c))
2032 AddRecordToResponseList(nrpp, &m->DeviceInfo, rr);
2033 }
2034 }
2035}
2036
2037mDNSlocal int AnonInfoSpace(AnonymousInfo *info)
2038{
2039 ResourceRecord *rr = info->nsec3RR;
2040
2041 // 2 bytes for compressed name + type (2) class (2) TTL (4) rdlength (2) rdata (n)
2042 return (2 + 10 + rr->rdlength);
2043}
2044
2045mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID)
2046{
2047 AuthRecord *rr;
2048 AuthRecord *ResponseRecords = mDNSNULL;
2049 AuthRecord **nrp = &ResponseRecords;
2050 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID);
2051 int AnoninfoSpace = 0;
2052
2053 // Make a list of all our records that need to be unicast to this destination
2054 for (rr = m->ResourceRecords; rr; rr=rr->next)
2055 {
2056 // If we find we can no longer unicast this answer, clear ImmedUnicast
2057 if (rr->ImmedAnswer == mDNSInterfaceMark ||
2058 mDNSSameIPv4Address(rr->v4Requester, onesIPv4Addr) ||
2059 mDNSSameIPv6Address(rr->v6Requester, onesIPv6Addr) )
2060 rr->ImmedUnicast = mDNSfalse;
2061
2062 if (rr->ImmedUnicast && rr->ImmedAnswer == InterfaceID)
2063 {
2064 if ((dest->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->v4Requester, dest->ip.v4)) ||
2065 (dest->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->v6Requester, dest->ip.v6)))
2066 {
2067 rr->ImmedAnswer = mDNSNULL; // Clear the state fields
2068 rr->ImmedUnicast = mDNSfalse;
2069 rr->v4Requester = zerov4Addr;
2070 rr->v6Requester = zerov6Addr;
2071
2072 // Only sent records registered for P2P over P2P interfaces
2073 if (intf && !mDNSPlatformValidRecordForInterface(rr, intf->InterfaceID))
2074 {
2075 continue;
2076 }
2077
2078 if (rr->NextResponse == mDNSNULL && nrp != &rr->NextResponse) // rr->NR_AnswerTo
2079 {
2080 rr->NR_AnswerTo = NR_AnswerMulticast;
2081 *nrp = rr;
2082 nrp = &rr->NextResponse;
2083 }
2084 }
2085 }
2086 }
2087
2088 AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID);
2089
2090 while (ResponseRecords)
2091 {
2092 mDNSu8 *responseptr = m->omsg.data;
2093 mDNSu8 *newptr;
2094 InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags);
2095
2096 // Put answers in the packet
2097 while (ResponseRecords && ResponseRecords->NR_AnswerTo)
2098 {
2099 rr = ResponseRecords;
2100 if (rr->resrec.AnonInfo)
2101 {
2102 AnoninfoSpace += AnonInfoSpace(rr->resrec.AnonInfo);
2103 rr->resrec.AnonInfo->SendNow = mDNSInterfaceMark;
2104 }
2105 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
2106 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
2107
2108 // Retract the limit by AnoninfoSpace which we need to put the AnoInfo option.
2109 newptr = PutResourceRecordTTLWithLimit(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl,
2110 m->omsg.data + (AllowedRRSpace(&m->omsg) - AnoninfoSpace));
2111
2112 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
2113 if (!newptr && m->omsg.h.numAnswers)
2114 {
2115 break; // If packet full, send it now
2116 }
2117 if (newptr) responseptr = newptr;
2118 ResponseRecords = rr->NextResponse;
2119 rr->NextResponse = mDNSNULL;
2120 rr->NR_AnswerTo = mDNSNULL;
2121 rr->NR_AdditionalTo = mDNSNULL;
2122 rr->RequireGoodbye = mDNStrue;
2123 }
2124
2125 // We have reserved the space for AnonInfo option. PutResourceRecord uses the
2126 // standard limit (AllowedRRSpace) and we should have space now.
2127 for (rr = m->ResourceRecords; rr; rr=rr->next)
2128 {
2129 if (rr->resrec.AnonInfo && rr->resrec.AnonInfo->SendNow == mDNSInterfaceMark)
2130 {
2131 ResourceRecord *nsec3RR = rr->resrec.AnonInfo->nsec3RR;
2132
2133 newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAuthorities, nsec3RR);
2134 if (newptr)
2135 {
2136 responseptr = newptr;
2137 debugf("SendDelayedUnicastResponse: Added NSEC3 Record %s on %p", RRDisplayString(m, nsec3RR), intf->InterfaceID);
2138 }
2139 else
2140 {
2141 // We allocated space and we should not fail. Don't break, we need to clear the SendNow flag.
2142 LogMsg("SendDelayedUnicastResponse: ERROR!! Cannot Add NSEC3 Record %s on %p", RRDisplayString(m, nsec3RR), intf->InterfaceID);
2143 }
2144 rr->resrec.AnonInfo->SendNow = mDNSNULL;
2145 }
2146 }
2147
2148 // Add additionals, if there's space
2149 while (ResponseRecords && !ResponseRecords->NR_AnswerTo)
2150 {
2151 rr = ResponseRecords;
2152 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
2153 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
2154 newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &rr->resrec);
2155 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
2156
2157 if (newptr) responseptr = newptr;
2158 if (newptr && m->omsg.h.numAnswers) rr->RequireGoodbye = mDNStrue;
2159 else if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) rr->ImmedAnswer = mDNSInterfaceMark;
2160 ResponseRecords = rr->NextResponse;
2161 rr->NextResponse = mDNSNULL;
2162 rr->NR_AnswerTo = mDNSNULL;
2163 rr->NR_AdditionalTo = mDNSNULL;
2164 }
2165
2166 if (m->omsg.h.numAnswers)
2167 mDNSSendDNSMessage(m, &m->omsg, responseptr, InterfaceID, mDNSNULL, dest, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse);
2168 }
2169}
2170
2171// CompleteDeregistration guarantees that on exit the record will have been cut from the m->ResourceRecords list
2172// and the client's mStatus_MemFree callback will have been invoked
2173mDNSexport void CompleteDeregistration(mDNS *const m, AuthRecord *rr)
2174{
2175 LogInfo("CompleteDeregistration: called for Resource record %s", ARDisplayString(m, rr));
2176 // Clearing rr->RequireGoodbye signals mDNS_Deregister_internal() that
2177 // it should go ahead and immediately dispose of this registration
2178 rr->resrec.RecordType = kDNSRecordTypeShared;
2179 rr->RequireGoodbye = mDNSfalse;
2180 rr->WakeUp.HMAC = zeroEthAddr;
2181 if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; }
2182 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); // Don't touch rr after this
2183}
2184
2185// DiscardDeregistrations is used on shutdown and sleep to discard (forcibly and immediately)
2186// any deregistering records that remain in the m->ResourceRecords list.
2187// DiscardDeregistrations calls mDNS_Deregister_internal which can call a user callback,
2188// which may change the record list and/or question list.
2189// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
2190mDNSlocal void DiscardDeregistrations(mDNS *const m)
2191{
2192 if (m->CurrentRecord)
2193 LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
2194 m->CurrentRecord = m->ResourceRecords;
2195
2196 while (m->CurrentRecord)
2197 {
2198 AuthRecord *rr = m->CurrentRecord;
2199 if (!AuthRecord_uDNS(rr) && rr->resrec.RecordType == kDNSRecordTypeDeregistering)
2200 CompleteDeregistration(m, rr); // Don't touch rr after this
2201 else
2202 m->CurrentRecord = rr->next;
2203 }
2204}
2205
2206mDNSlocal mStatus GetLabelDecimalValue(const mDNSu8 *const src, mDNSu8 *dst)
2207{
2208 int i, val = 0;
2209 if (src[0] < 1 || src[0] > 3) return(mStatus_Invalid);
2210 for (i=1; i<=src[0]; i++)
2211 {
2212 if (src[i] < '0' || src[i] > '9') return(mStatus_Invalid);
2213 val = val * 10 + src[i] - '0';
2214 }
2215 if (val > 255) return(mStatus_Invalid);
2216 *dst = (mDNSu8)val;
2217 return(mStatus_NoError);
2218}
2219
2220mDNSlocal mStatus GetIPv4FromName(mDNSAddr *const a, const domainname *const name)
2221{
2222 int skip = CountLabels(name) - 6;
2223 if (skip < 0) { LogMsg("GetIPFromName: Need six labels in IPv4 reverse mapping name %##s", name); return mStatus_Invalid; }
2224 if (GetLabelDecimalValue(SkipLeadingLabels(name, skip+3)->c, &a->ip.v4.b[0]) ||
2225 GetLabelDecimalValue(SkipLeadingLabels(name, skip+2)->c, &a->ip.v4.b[1]) ||
2226 GetLabelDecimalValue(SkipLeadingLabels(name, skip+1)->c, &a->ip.v4.b[2]) ||
2227 GetLabelDecimalValue(SkipLeadingLabels(name, skip+0)->c, &a->ip.v4.b[3])) return mStatus_Invalid;
2228 a->type = mDNSAddrType_IPv4;
2229 return(mStatus_NoError);
2230}
2231
2232#define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0' ) : \
2233 ((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) : \
2234 ((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : -1)
2235
2236mDNSlocal mStatus GetIPv6FromName(mDNSAddr *const a, const domainname *const name)
2237{
2238 int i, h, l;
2239 const domainname *n;
2240
2241 int skip = CountLabels(name) - 34;
2242 if (skip < 0) { LogMsg("GetIPFromName: Need 34 labels in IPv6 reverse mapping name %##s", name); return mStatus_Invalid; }
2243
2244 n = SkipLeadingLabels(name, skip);
2245 for (i=0; i<16; i++)
2246 {
2247 if (n->c[0] != 1) return mStatus_Invalid;
2248 l = HexVal(n->c[1]);
2249 n = (const domainname *)(n->c + 2);
2250
2251 if (n->c[0] != 1) return mStatus_Invalid;
2252 h = HexVal(n->c[1]);
2253 n = (const domainname *)(n->c + 2);
2254
2255 if (l<0 || h<0) return mStatus_Invalid;
2256 a->ip.v6.b[15-i] = (mDNSu8)((h << 4) | l);
2257 }
2258
2259 a->type = mDNSAddrType_IPv6;
2260 return(mStatus_NoError);
2261}
2262
2263mDNSlocal mDNSs32 ReverseMapDomainType(const domainname *const name)
2264{
2265 int skip = CountLabels(name) - 2;
2266 if (skip >= 0)
2267 {
2268 const domainname *suffix = SkipLeadingLabels(name, skip);
2269 if (SameDomainName(suffix, (const domainname*)"\x7" "in-addr" "\x4" "arpa")) return mDNSAddrType_IPv4;
2270 if (SameDomainName(suffix, (const domainname*)"\x3" "ip6" "\x4" "arpa")) return mDNSAddrType_IPv6;
2271 }
2272 return(mDNSAddrType_None);
2273}
2274
2275mDNSlocal void SendARP(mDNS *const m, const mDNSu8 op, const AuthRecord *const rr,
2276 const mDNSv4Addr *const spa, const mDNSEthAddr *const tha, const mDNSv4Addr *const tpa, const mDNSEthAddr *const dst)
2277{
2278 int i;
2279 mDNSu8 *ptr = m->omsg.data;
2280 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID);
2281 if (!intf) { LogMsg("SendARP: No interface with InterfaceID %p found %s", rr->resrec.InterfaceID, ARDisplayString(m,rr)); return; }
2282
2283 // 0x00 Destination address
2284 for (i=0; i<6; i++) *ptr++ = dst->b[i];
2285
2286 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us)
2287 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[0];
2288
2289 // 0x0C ARP Ethertype (0x0806)
2290 *ptr++ = 0x08; *ptr++ = 0x06;
2291
2292 // 0x0E ARP header
2293 *ptr++ = 0x00; *ptr++ = 0x01; // Hardware address space; Ethernet = 1
2294 *ptr++ = 0x08; *ptr++ = 0x00; // Protocol address space; IP = 0x0800
2295 *ptr++ = 6; // Hardware address length
2296 *ptr++ = 4; // Protocol address length
2297 *ptr++ = 0x00; *ptr++ = op; // opcode; Request = 1, Response = 2
2298
2299 // 0x16 Sender hardware address (our MAC address)
2300 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[i];
2301
2302 // 0x1C Sender protocol address
2303 for (i=0; i<4; i++) *ptr++ = spa->b[i];
2304
2305 // 0x20 Target hardware address
2306 for (i=0; i<6; i++) *ptr++ = tha->b[i];
2307
2308 // 0x26 Target protocol address
2309 for (i=0; i<4; i++) *ptr++ = tpa->b[i];
2310
2311 // 0x2A Total ARP Packet length 42 bytes
2312 mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID);
2313}
2314
2315mDNSlocal mDNSu16 CheckSum(const void *const data, mDNSs32 length, mDNSu32 sum)
2316{
2317 const mDNSu16 *ptr = data;
2318 while (length > 0) { length -= 2; sum += *ptr++; }
2319 sum = (sum & 0xFFFF) + (sum >> 16);
2320 sum = (sum & 0xFFFF) + (sum >> 16);
2321 return(sum != 0xFFFF ? sum : 0);
2322}
2323
2324mDNSlocal mDNSu16 IPv6CheckSum(const mDNSv6Addr *const src, const mDNSv6Addr *const dst, const mDNSu8 protocol, const void *const data, const mDNSu32 length)
2325{
2326 IPv6PseudoHeader ph;
2327 ph.src = *src;
2328 ph.dst = *dst;
2329 ph.len.b[0] = length >> 24;
2330 ph.len.b[1] = length >> 16;
2331 ph.len.b[2] = length >> 8;
2332 ph.len.b[3] = length;
2333 ph.pro.b[0] = 0;
2334 ph.pro.b[1] = 0;
2335 ph.pro.b[2] = 0;
2336 ph.pro.b[3] = protocol;
2337 return CheckSum(&ph, sizeof(ph), CheckSum(data, length, 0));
2338}
2339
2340mDNSlocal void SendNDP(mDNS *const m, const mDNSu8 op, const mDNSu8 flags, const AuthRecord *const rr,
2341 const mDNSv6Addr *const spa, const mDNSEthAddr *const tha, const mDNSv6Addr *const tpa, const mDNSEthAddr *const dst)
2342{
2343 int i;
2344 mDNSOpaque16 checksum;
2345 mDNSu8 *ptr = m->omsg.data;
2346 // Some recipient hosts seem to ignore Neighbor Solicitations if the IPv6-layer destination address is not the
2347 // appropriate IPv6 solicited node multicast address, so we use that IPv6-layer destination address, even though
2348 // at the Ethernet-layer we unicast the packet to the intended target, to avoid wasting network bandwidth.
2349 const mDNSv6Addr mc = { { 0xFF,0x02,0x00,0x00, 0,0,0,0, 0,0,0,1, 0xFF,tpa->b[0xD],tpa->b[0xE],tpa->b[0xF] } };
2350 const mDNSv6Addr *const v6dst = (op == NDP_Sol) ? &mc : tpa;
2351 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID);
2352 if (!intf) { LogMsg("SendNDP: No interface with InterfaceID %p found %s", rr->resrec.InterfaceID, ARDisplayString(m,rr)); return; }
2353
2354 // 0x00 Destination address
2355 for (i=0; i<6; i++) *ptr++ = dst->b[i];
2356 // Right now we only send Neighbor Solicitations to verify whether the host we're proxying for has gone to sleep yet.
2357 // Since we know who we're looking for, we send it via Ethernet-layer unicast, rather than bothering every host on the
2358 // link with a pointless link-layer multicast.
2359 // Should we want to send traditional Neighbor Solicitations in the future, where we really don't know in advance what
2360 // Ethernet-layer address we're looking for, we'll need to send to the appropriate Ethernet-layer multicast address:
2361 // *ptr++ = 0x33;
2362 // *ptr++ = 0x33;
2363 // *ptr++ = 0xFF;
2364 // *ptr++ = tpa->b[0xD];
2365 // *ptr++ = tpa->b[0xE];
2366 // *ptr++ = tpa->b[0xF];
2367
2368 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us)
2369 for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i];
2370
2371 // 0x0C IPv6 Ethertype (0x86DD)
2372 *ptr++ = 0x86; *ptr++ = 0xDD;
2373
2374 // 0x0E IPv6 header
2375 *ptr++ = 0x60; *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00; // Version, Traffic Class, Flow Label
2376 *ptr++ = 0x00; *ptr++ = 0x20; // Length
2377 *ptr++ = 0x3A; // Protocol == ICMPv6
2378 *ptr++ = 0xFF; // Hop Limit
2379
2380 // 0x16 Sender IPv6 address
2381 for (i=0; i<16; i++) *ptr++ = spa->b[i];
2382
2383 // 0x26 Destination IPv6 address
2384 for (i=0; i<16; i++) *ptr++ = v6dst->b[i];
2385
2386 // 0x36 NDP header
2387 *ptr++ = op; // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement
2388 *ptr++ = 0x00; // Code
2389 *ptr++ = 0x00; *ptr++ = 0x00; // Checksum placeholder (0x38, 0x39)
2390 *ptr++ = flags;
2391 *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00;
2392
2393 if (op == NDP_Sol) // Neighbor Solicitation. The NDP "target" is the address we seek.
2394 {
2395 // 0x3E NDP target.
2396 for (i=0; i<16; i++) *ptr++ = tpa->b[i];
2397 // 0x4E Source Link-layer Address
2398 // <http://www.ietf.org/rfc/rfc2461.txt>
2399 // MUST NOT be included when the source IP address is the unspecified address.
2400 // Otherwise, on link layers that have addresses this option MUST be included
2401 // in multicast solicitations and SHOULD be included in unicast solicitations.
2402 if (!mDNSIPv6AddressIsZero(*spa))
2403 {
2404 *ptr++ = NDP_SrcLL; // Option Type 1 == Source Link-layer Address
2405 *ptr++ = 0x01; // Option length 1 (in units of 8 octets)
2406 for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i];
2407 }
2408 }
2409 else // Neighbor Advertisement. The NDP "target" is the address we're giving information about.
2410 {
2411 // 0x3E NDP target.
2412 for (i=0; i<16; i++) *ptr++ = spa->b[i];
2413 // 0x4E Target Link-layer Address
2414 *ptr++ = NDP_TgtLL; // Option Type 2 == Target Link-layer Address
2415 *ptr++ = 0x01; // Option length 1 (in units of 8 octets)
2416 for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i];
2417 }
2418
2419 // 0x4E or 0x56 Total NDP Packet length 78 or 86 bytes
2420 m->omsg.data[0x13] = ptr - &m->omsg.data[0x36]; // Compute actual length
2421 checksum.NotAnInteger = ~IPv6CheckSum(spa, v6dst, 0x3A, &m->omsg.data[0x36], m->omsg.data[0x13]);
2422 m->omsg.data[0x38] = checksum.b[0];
2423 m->omsg.data[0x39] = checksum.b[1];
2424
2425 mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID);
2426}
2427
2428mDNSlocal void SetupTracerOpt(const mDNS *const m, rdataOPT *const Trace)
2429{
2430 mDNSu32 DNS_VERS = _DNS_SD_H;
2431 Trace->u.tracer.platf = m->mDNS_plat;
2432 Trace->u.tracer.mDNSv = DNS_VERS;
2433
2434 Trace->opt = kDNSOpt_Trace;
2435 Trace->optlen = DNSOpt_TraceData_Space - 4;
2436}
2437
2438mDNSlocal void SetupOwnerOpt(const mDNS *const m, const NetworkInterfaceInfo *const intf, rdataOPT *const owner)
2439{
2440 owner->u.owner.vers = 0;
2441 owner->u.owner.seq = m->SleepSeqNum;
2442 owner->u.owner.HMAC = m->PrimaryMAC;
2443 owner->u.owner.IMAC = intf->MAC;
2444 owner->u.owner.password = zeroEthAddr;
2445
2446 // Don't try to compute the optlen until *after* we've set up the data fields
2447 // Right now the DNSOpt_Owner_Space macro does not depend on the owner->u.owner being set up correctly, but in the future it might
2448 owner->opt = kDNSOpt_Owner;
2449 owner->optlen = DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) - 4;
2450}
2451
2452mDNSlocal void GrantUpdateCredit(AuthRecord *rr)
2453{
2454 if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0;
2455 else rr->NextUpdateCredit = NonZeroTime(rr->NextUpdateCredit + kUpdateCreditRefreshInterval);
2456}
2457
2458mDNSlocal mDNSBool ShouldSendGoodbyesBeforeSleep(mDNS *const m, const NetworkInterfaceInfo *intf, AuthRecord *rr)
2459{
2460 // If there are no sleep proxies, we set the state to SleepState_Sleeping explicitly
2461 // and hence there is no need to check for Transfering state. But if we have sleep
2462 // proxies and partially sending goodbyes for some records, we will be in Transfering
2463 // state and hence need to make sure that we send goodbyes in that case too. Checking whether
2464 // we are not awake handles both cases.
2465 if ((rr->AuthFlags & AuthFlagsWakeOnly) && (m->SleepState != SleepState_Awake))
2466 {
2467 debugf("ShouldSendGoodbyesBeforeSleep: marking for goodbye", ARDisplayString(m, rr));
2468 return mDNStrue;
2469 }
2470
2471 if (m->SleepState != SleepState_Sleeping)
2472 return mDNSfalse;
2473
2474 // If we are going to sleep and in SleepState_Sleeping, SendGoodbyes on the interface tell you
2475 // whether you can send goodbyes or not.
2476 if (!intf->SendGoodbyes)
2477 {
2478 debugf("ShouldSendGoodbyesBeforeSleep: not sending goodbye %s, int %p", ARDisplayString(m, rr), intf->InterfaceID);
2479 return mDNSfalse;
2480 }
2481 else
2482 {
2483 debugf("ShouldSendGoodbyesBeforeSleep: sending goodbye %s, int %p", ARDisplayString(m, rr), intf->InterfaceID);
2484 return mDNStrue;
2485 }
2486}
2487
2488mDNSlocal mDNSBool IsInterfaceValidForAuthRecord(const AuthRecord *ar, mDNSInterfaceID InterfaceID)
2489{
2490 mDNSBool result;
2491
2492 if (ar->resrec.InterfaceID == mDNSInterface_Any)
2493 {
2494 result = mDNSPlatformValidRecordForInterface(ar, InterfaceID);
2495 }
2496 else
2497 {
2498 result = (ar->resrec.InterfaceID == InterfaceID);
2499 }
2500
2501 return(result);
2502}
2503
2504// Note about acceleration of announcements to facilitate automatic coalescing of
2505// multiple independent threads of announcements into a single synchronized thread:
2506// The announcements in the packet may be at different stages of maturity;
2507// One-second interval, two-second interval, four-second interval, and so on.
2508// After we've put in all the announcements that are due, we then consider
2509// whether there are other nearly-due announcements that are worth accelerating.
2510// To be eligible for acceleration, a record MUST NOT be older (further along
2511// its timeline) than the most mature record we've already put in the packet.
2512// In other words, younger records can have their timelines accelerated to catch up
2513// with their elder bretheren; this narrows the age gap and helps them eventually get in sync.
2514// Older records cannot have their timelines accelerated; this would just widen
2515// the gap between them and their younger bretheren and get them even more out of sync.
2516
2517// Note: SendResponses calls mDNS_Deregister_internal which can call a user callback, which may change
2518// the record list and/or question list.
2519// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
2520mDNSlocal void SendResponses(mDNS *const m)
2521{
2522 int pktcount = 0;
2523 AuthRecord *rr, *r2;
2524 mDNSs32 maxExistingAnnounceInterval = 0;
2525 const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
2526
2527 m->NextScheduledResponse = m->timenow + FutureTime;
2528
2529 if (m->SleepState == SleepState_Transferring) RetrySPSRegistrations(m);
2530
2531 for (rr = m->ResourceRecords; rr; rr=rr->next)
2532 if (rr->ImmedUnicast)
2533 {
2534 mDNSAddr v4 = { mDNSAddrType_IPv4, {{{0}}} };
2535 mDNSAddr v6 = { mDNSAddrType_IPv6, {{{0}}} };
2536 v4.ip.v4 = rr->v4Requester;
2537 v6.ip.v6 = rr->v6Requester;
2538 if (!mDNSIPv4AddressIsZero(rr->v4Requester)) SendDelayedUnicastResponse(m, &v4, rr->ImmedAnswer);
2539 if (!mDNSIPv6AddressIsZero(rr->v6Requester)) SendDelayedUnicastResponse(m, &v6, rr->ImmedAnswer);
2540 if (rr->ImmedUnicast)
2541 {
2542 LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s", ARDisplayString(m, rr));
2543 rr->ImmedUnicast = mDNSfalse;
2544 }
2545 }
2546
2547 // ***
2548 // *** 1. Setup: Set the SendRNow and ImmedAnswer fields to indicate which interface(s) the records need to be sent on
2549 // ***
2550
2551 // Run through our list of records, and decide which ones we're going to announce on all interfaces
2552 for (rr = m->ResourceRecords; rr; rr=rr->next)
2553 {
2554 while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr);
2555 if (TimeToAnnounceThisRecord(rr, m->timenow))
2556 {
2557 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
2558 {
2559 if (!rr->WakeUp.HMAC.l[0])
2560 {
2561 if (rr->AnnounceCount) rr->ImmedAnswer = mDNSInterfaceMark; // Send goodbye packet on all interfaces
2562 }
2563 else
2564 {
2565 mDNSBool unicastOnly;
2566 LogSPS("SendResponses: Sending wakeup %2d for %.6a %s", rr->AnnounceCount-3, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
2567 unicastOnly = ((rr->AnnounceCount == WakeupCount) || (rr->AnnounceCount == WakeupCount - 1)) ? mDNStrue : mDNSfalse;
2568 SendWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.IMAC, &rr->WakeUp.password, unicastOnly);
2569 for (r2 = rr; r2; r2=r2->next)
2570 if ((r2->resrec.RecordType == kDNSRecordTypeDeregistering) && r2->AnnounceCount && (r2->resrec.InterfaceID == rr->resrec.InterfaceID) &&
2571 mDNSSameEthAddress(&r2->WakeUp.IMAC, &rr->WakeUp.IMAC) && !mDNSSameEthAddress(&zeroEthAddr, &r2->WakeUp.HMAC))
2572 {
2573 // For now we only want to send a single Unsolicited Neighbor Advertisement restoring the address to the original
2574 // owner, because these packets can cause some IPv6 stacks to falsely conclude that there's an address conflict.
2575 if (r2->AddressProxy.type == mDNSAddrType_IPv6 && r2->AnnounceCount == WakeupCount)
2576 {
2577 LogSPS("NDP Announcement %2d Releasing traffic for H-MAC %.6a I-MAC %.6a %s",
2578 r2->AnnounceCount-3, &r2->WakeUp.HMAC, &r2->WakeUp.IMAC, ARDisplayString(m,r2));
2579 SendNDP(m, NDP_Adv, NDP_Override, r2, &r2->AddressProxy.ip.v6, &r2->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth);
2580 }
2581 r2->LastAPTime = m->timenow;
2582 // After 15 wakeups without success (maybe host has left the network) send three goodbyes instead
2583 if (--r2->AnnounceCount <= GoodbyeCount) r2->WakeUp.HMAC = zeroEthAddr;
2584 }
2585 }
2586 }
2587 else if (ResourceRecordIsValidAnswer(rr))
2588 {
2589 if (rr->AddressProxy.type)
2590 {
2591 if (!mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC))
2592 {
2593 rr->AnnounceCount--;
2594 rr->ThisAPInterval *= 2;
2595 rr->LastAPTime = m->timenow;
2596 if (rr->AddressProxy.type == mDNSAddrType_IPv4)
2597 {
2598 LogSPS("ARP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s",
2599 rr->AnnounceCount, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr));
2600 SendARP(m, 1, rr, &rr->AddressProxy.ip.v4, &zeroEthAddr, &rr->AddressProxy.ip.v4, &onesEthAddr);
2601 }
2602 else if (rr->AddressProxy.type == mDNSAddrType_IPv6)
2603 {
2604 LogSPS("NDP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s",
2605 rr->AnnounceCount, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr));
2606 SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, mDNSNULL, &AllHosts_v6, &AllHosts_v6_Eth);
2607 }
2608 }
2609 }
2610 else
2611 {
2612 rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces
2613 if (maxExistingAnnounceInterval < rr->ThisAPInterval)
2614 maxExistingAnnounceInterval = rr->ThisAPInterval;
2615 if (rr->UpdateBlocked) rr->UpdateBlocked = 0;
2616 }
2617 }
2618 }
2619 }
2620
2621 // Any interface-specific records we're going to send are marked as being sent on all appropriate interfaces (which is just one)
2622 // Eligible records that are more than half-way to their announcement time are accelerated
2623 for (rr = m->ResourceRecords; rr; rr=rr->next)
2624 if ((rr->resrec.InterfaceID && rr->ImmedAnswer) ||
2625 (rr->ThisAPInterval <= maxExistingAnnounceInterval &&
2626 TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2) &&
2627 !rr->AddressProxy.type && // Don't include ARP Annoucements when considering which records to accelerate
2628 ResourceRecordIsValidAnswer(rr)))
2629 rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces
2630
2631 // When sending SRV records (particularly when announcing a new service) automatically add related Address record(s) as additionals
2632 // Note: Currently all address records are interface-specific, so it's safe to set ImmedAdditional to their InterfaceID,
2633 // which will be non-null. If by some chance there is an address record that's not interface-specific (should never happen)
2634 // then all that means is that it won't get sent -- which would not be the end of the world.
2635 for (rr = m->ResourceRecords; rr; rr=rr->next)
2636 {
2637 if (rr->ImmedAnswer && rr->resrec.rrtype == kDNSType_SRV)
2638 for (r2=m->ResourceRecords; r2; r2=r2->next) // Scan list of resource records
2639 if (RRTypeIsAddressType(r2->resrec.rrtype) && // For all address records (A/AAAA) ...
2640 ResourceRecordIsValidAnswer(r2) && // ... which are valid for answer ...
2641 rr->LastMCTime - r2->LastMCTime >= 0 && // ... which we have not sent recently ...
2642 rr->resrec.rdatahash == r2->resrec.namehash && // ... whose name is the name of the SRV target
2643 SameDomainName(&rr->resrec.rdata->u.srv.target, r2->resrec.name) &&
2644 (rr->ImmedAnswer == mDNSInterfaceMark || rr->ImmedAnswer == r2->resrec.InterfaceID))
2645 r2->ImmedAdditional = r2->resrec.InterfaceID; // ... then mark this address record for sending too
2646 // We also make sure we send the DeviceInfo TXT record too, if necessary
2647 // We check for RecordType == kDNSRecordTypeShared because we don't want to tag the
2648 // DeviceInfo TXT record onto a goodbye packet (RecordType == kDNSRecordTypeDeregistering).
2649 if (rr->ImmedAnswer && rr->resrec.RecordType == kDNSRecordTypeShared && rr->resrec.rrtype == kDNSType_PTR)
2650 if (ResourceRecordIsValidAnswer(&m->DeviceInfo) && SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c))
2651 {
2652 if (!m->DeviceInfo.ImmedAnswer) m->DeviceInfo.ImmedAnswer = rr->ImmedAnswer;
2653 else m->DeviceInfo.ImmedAnswer = mDNSInterfaceMark;
2654 }
2655 }
2656
2657 // If there's a record which is supposed to be unique that we're going to send, then make sure that we give
2658 // the whole RRSet as an atomic unit. That means that if we have any other records with the same name/type/class
2659 // then we need to mark them for sending too. Otherwise, if we set the kDNSClass_UniqueRRSet bit on a
2660 // record, then other RRSet members that have not been sent recently will get flushed out of client caches.
2661 // -- If a record is marked to be sent on a certain interface, make sure the whole set is marked to be sent on that interface
2662 // -- If any record is marked to be sent on all interfaces, make sure the whole set is marked to be sent on all interfaces
2663 for (rr = m->ResourceRecords; rr; rr=rr->next)
2664 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
2665 {
2666 if (rr->ImmedAnswer) // If we're sending this as answer, see that its whole RRSet is similarly marked
2667 {
2668 for (r2 = m->ResourceRecords; r2; r2=r2->next)
2669 {
2670 if ((r2->resrec.RecordType & kDNSRecordTypeUniqueMask) && ResourceRecordIsValidAnswer(r2) &&
2671 (r2->ImmedAnswer != mDNSInterfaceMark) && (r2->ImmedAnswer != rr->ImmedAnswer) &&
2672 SameResourceRecordSignature(r2, rr) &&
2673 ((rr->ImmedAnswer == mDNSInterfaceMark) || IsInterfaceValidForAuthRecord(r2, rr->ImmedAnswer)))
2674 {
2675 r2->ImmedAnswer = !r2->ImmedAnswer ? rr->ImmedAnswer : mDNSInterfaceMark;
2676 }
2677 }
2678 }
2679 else if (rr->ImmedAdditional) // If we're sending this as additional, see that its whole RRSet is similarly marked
2680 {
2681 for (r2 = m->ResourceRecords; r2; r2=r2->next)
2682 {
2683 if ((r2->resrec.RecordType & kDNSRecordTypeUniqueMask) && ResourceRecordIsValidAnswer(r2) &&
2684 (r2->ImmedAdditional != rr->ImmedAdditional) &&
2685 SameResourceRecordSignature(r2, rr) &&
2686 IsInterfaceValidForAuthRecord(r2, rr->ImmedAdditional))
2687 {
2688 r2->ImmedAdditional = rr->ImmedAdditional;
2689 }
2690 }
2691 }
2692 }
2693
2694 // Now set SendRNow state appropriately
2695 for (rr = m->ResourceRecords; rr; rr=rr->next)
2696 {
2697 if (rr->ImmedAnswer == mDNSInterfaceMark) // Sending this record on all appropriate interfaces
2698 {
2699 rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID;
2700 rr->ImmedAdditional = mDNSNULL; // No need to send as additional if sending as answer
2701 rr->LastMCTime = m->timenow;
2702 rr->LastMCInterface = rr->ImmedAnswer;
2703 rr->ProbeRestartCount = 0; // Reset the probe restart count
2704 // If we're announcing this record, and it's at least half-way to its ordained time, then consider this announcement done
2705 if (TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2))
2706 {
2707 rr->AnnounceCount--;
2708 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering)
2709 rr->ThisAPInterval *= 2;
2710 rr->LastAPTime = m->timenow;
2711 debugf("Announcing %##s (%s) %d", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount);
2712 }
2713 }
2714 else if (rr->ImmedAnswer) // Else, just respond to a single query on single interface:
2715 {
2716 rr->SendRNow = rr->ImmedAnswer; // Just respond on that interface
2717 rr->ImmedAdditional = mDNSNULL; // No need to send as additional too
2718 rr->LastMCTime = m->timenow;
2719 rr->LastMCInterface = rr->ImmedAnswer;
2720 }
2721 SetNextAnnounceProbeTime(m, rr);
2722 //if (rr->SendRNow) LogMsg("%-15.4a %s", &rr->v4Requester, ARDisplayString(m, rr));
2723 }
2724
2725 // ***
2726 // *** 2. Loop through interface list, sending records as appropriate
2727 // ***
2728
2729 while (intf)
2730 {
2731 int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0;
2732 int TraceRecordSpace = (mDNS_McastTracingEnabled && MDNS_TRACER) ? DNSOpt_Header_Space + DNSOpt_TraceData_Space : 0;
2733 int numDereg = 0;
2734 int numAnnounce = 0;
2735 int numAnswer = 0;
2736 int AnoninfoSpace = 0;
2737 mDNSu8 *responseptr = m->omsg.data;
2738 mDNSu8 *newptr;
2739 InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags);
2740
2741 // First Pass. Look for:
2742 // 1. Deregistering records that need to send their goodbye packet
2743 // 2. Updated records that need to retract their old data
2744 // 3. Answers and announcements we need to send
2745 for (rr = m->ResourceRecords; rr; rr=rr->next)
2746 {
2747
2748 // Skip this interface if the record InterfaceID is *Any and the record is not
2749 // appropriate for the interface type.
2750 if ((rr->SendRNow == intf->InterfaceID) &&
2751 ((rr->resrec.InterfaceID == mDNSInterface_Any) && !mDNSPlatformValidRecordForInterface(rr, intf->InterfaceID)))
2752 {
2753 rr->SendRNow = GetNextActiveInterfaceID(intf);
2754 }
2755 else if (rr->SendRNow == intf->InterfaceID)
2756 {
2757 RData *OldRData = rr->resrec.rdata;
2758 mDNSu16 oldrdlength = rr->resrec.rdlength;
2759 mDNSu8 active = (mDNSu8)
2760 (rr->resrec.RecordType != kDNSRecordTypeDeregistering && !ShouldSendGoodbyesBeforeSleep(m, intf, rr));
2761 newptr = mDNSNULL;
2762 if (rr->NewRData && active)
2763 {
2764 // See if we should send a courtesy "goodbye" for the old data before we replace it.
2765 if (ResourceRecordIsValidAnswer(rr) && rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye)
2766 {
2767 newptr = PutRR_OS_TTL(responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0);
2768 if (newptr) { responseptr = newptr; numDereg++; rr->RequireGoodbye = mDNSfalse; }
2769 else continue; // If this packet is already too full to hold the goodbye for this record, skip it for now and we'll retry later
2770 }
2771 SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength);
2772 }
2773
2774 if (rr->resrec.AnonInfo)
2775 {
2776 int tmp = AnonInfoSpace(rr->resrec.AnonInfo);
2777
2778 AnoninfoSpace += tmp;
2779 // Adjust OwnerRecordSpace/TraceRecordSpace which is used by PutRR_OS_TTL below so that
2780 // we have space to put in the NSEC3 record in the authority section.
2781 OwnerRecordSpace += tmp;
2782 TraceRecordSpace += tmp;
2783 }
2784
2785 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
2786 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
2787 newptr = PutRR_OS_TTL(responseptr, &m->omsg.h.numAnswers, &rr->resrec, active ? rr->resrec.rroriginalttl : 0);
2788 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
2789 if (newptr)
2790 {
2791 responseptr = newptr;
2792 rr->RequireGoodbye = active;
2793 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) numDereg++;
2794 else if (rr->LastAPTime == m->timenow) numAnnounce++;else numAnswer++;
2795 }
2796
2797 if (rr->NewRData && active)
2798 SetNewRData(&rr->resrec, OldRData, oldrdlength);
2799
2800 // The first time through (pktcount==0), if this record is verified unique
2801 // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too.
2802 if (!pktcount && active && (rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && !rr->SendNSECNow)
2803 rr->SendNSECNow = mDNSInterfaceMark;
2804
2805 if (newptr) // If succeeded in sending, advance to next interface
2806 {
2807 if (rr->resrec.AnonInfo)
2808 {
2809 debugf("SendResponses: Marking %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p", ARDisplayString(m, rr), OwnerRecordSpace,
2810 TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace);
2811 rr->resrec.AnonInfo->SendNow = intf->InterfaceID;
2812 }
2813
2814 // If sending on all interfaces, go to next interface; else we're finished now
2815 if (rr->ImmedAnswer == mDNSInterfaceMark && rr->resrec.InterfaceID == mDNSInterface_Any)
2816 rr->SendRNow = GetNextActiveInterfaceID(intf);
2817 else
2818 rr->SendRNow = mDNSNULL;
2819 }
2820 }
2821 }
2822
2823 // Get the reserved space back
2824 OwnerRecordSpace -= AnoninfoSpace;
2825 TraceRecordSpace -= AnoninfoSpace;
2826 newptr = responseptr;
2827 for (rr = m->ResourceRecords; rr; rr=rr->next)
2828 {
2829 if (rr->resrec.AnonInfo && rr->resrec.AnonInfo->SendNow == intf->InterfaceID)
2830 {
2831 ResourceRecord *nsec3RR = rr->resrec.AnonInfo->nsec3RR;
2832
2833 newptr = PutRR_OS_TTL(newptr, &m->omsg.h.numAuthorities, nsec3RR, nsec3RR->rroriginalttl);
2834 if (newptr)
2835 {
2836 responseptr = newptr;
2837 debugf("SendResponses: Added NSEC3 %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p", ARDisplayString(m, rr), OwnerRecordSpace,
2838 TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace);
2839 }
2840 else
2841 {
2842 LogMsg("SendResponses: Cannot add NSEC3 %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p", ARDisplayString(m, rr), OwnerRecordSpace,
2843 TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace);
2844 }
2845 rr->resrec.AnonInfo->SendNow = mDNSNULL;
2846 }
2847 }
2848 // Second Pass. Add additional records, if there's space.
2849 newptr = responseptr;
2850 for (rr = m->ResourceRecords; rr; rr=rr->next)
2851 if (rr->ImmedAdditional == intf->InterfaceID)
2852 if (ResourceRecordIsValidAnswer(rr))
2853 {
2854 // If we have at least one answer already in the packet, then plan to add additionals too
2855 mDNSBool SendAdditional = (m->omsg.h.numAnswers > 0);
2856
2857 // If we're not planning to send any additionals, but this record is a unique one, then
2858 // make sure we haven't already sent any other members of its RRSet -- if we have, then they
2859 // will have had the cache flush bit set, so now we need to finish the job and send the rest.
2860 if (!SendAdditional && (rr->resrec.RecordType & kDNSRecordTypeUniqueMask))
2861 {
2862 const AuthRecord *a;
2863 for (a = m->ResourceRecords; a; a=a->next)
2864 if (a->LastMCTime == m->timenow &&
2865 a->LastMCInterface == intf->InterfaceID &&
2866 SameResourceRecordSignature(a, rr)) { SendAdditional = mDNStrue; break; }
2867 }
2868 if (!SendAdditional) // If we don't want to send this after all,
2869 rr->ImmedAdditional = mDNSNULL; // then cancel its ImmedAdditional field
2870 else if (newptr) // Else, try to add it if we can
2871 {
2872 // The first time through (pktcount==0), if this record is verified unique
2873 // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too.
2874 if (!pktcount && (rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && !rr->SendNSECNow)
2875 rr->SendNSECNow = mDNSInterfaceMark;
2876
2877 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
2878 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
2879 newptr = PutRR_OS(newptr, &m->omsg.h.numAdditionals, &rr->resrec);
2880 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
2881 if (newptr)
2882 {
2883 responseptr = newptr;
2884 rr->ImmedAdditional = mDNSNULL;
2885 rr->RequireGoodbye = mDNStrue;
2886 // If we successfully put this additional record in the packet, we record LastMCTime & LastMCInterface.
2887 // This matters particularly in the case where we have more than one IPv6 (or IPv4) address, because otherwise,
2888 // when we see our own multicast with the cache flush bit set, if we haven't set LastMCTime, then we'll get
2889 // all concerned and re-announce our record again to make sure it doesn't get flushed from peer caches.
2890 rr->LastMCTime = m->timenow;
2891 rr->LastMCInterface = intf->InterfaceID;
2892 }
2893 }
2894 }
2895
2896 // Third Pass. Add NSEC records, if there's space.
2897 // When we're generating an NSEC record in response to a specify query for that type
2898 // (recognized by rr->SendNSECNow == intf->InterfaceID) we should really put the NSEC in the Answer Section,
2899 // not Additional Section, but for now it's easier to handle both cases in this Additional Section loop here.
2900 for (rr = m->ResourceRecords; rr; rr=rr->next)
2901 if (rr->SendNSECNow == mDNSInterfaceMark || rr->SendNSECNow == intf->InterfaceID)
2902 {
2903 AuthRecord nsec;
2904 mDNSu8 *ptr;
2905 int len;
2906 mDNS_SetupResourceRecord(&nsec, mDNSNULL, mDNSInterface_Any, kDNSType_NSEC, rr->resrec.rroriginalttl, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
2907 nsec.resrec.rrclass |= kDNSClass_UniqueRRSet;
2908 AssignDomainName(&nsec.namestorage, rr->resrec.name);
2909 ptr = nsec.rdatastorage.u.data;
2910 len = DomainNameLength(rr->resrec.name);
2911 // We have a nxt name followed by window number, window length and a window bitmap
2912 nsec.resrec.rdlength = len + 2 + NSEC_MCAST_WINDOW_SIZE;
2913 if (nsec.resrec.rdlength <= StandardAuthRDSize)
2914 {
2915 mDNSPlatformMemZero(ptr, nsec.resrec.rdlength);
2916 AssignDomainName((domainname *)ptr, rr->resrec.name);
2917 ptr += len;
2918 *ptr++ = 0; // window number
2919 *ptr++ = NSEC_MCAST_WINDOW_SIZE; // window length
2920 for (r2 = m->ResourceRecords; r2; r2=r2->next)
2921 if (ResourceRecordIsValidAnswer(r2) && SameResourceRecordNameClassInterface(r2, rr))
2922 {
2923 if (r2->resrec.rrtype >= kDNSQType_ANY) { LogMsg("SendResponses: Can't create NSEC for record %s", ARDisplayString(m, r2)); break; }
2924 else ptr[r2->resrec.rrtype >> 3] |= 128 >> (r2->resrec.rrtype & 7);
2925 }
2926 newptr = responseptr;
2927 if (!r2) // If we successfully built our NSEC record, add it to the packet now
2928 {
2929 newptr = PutRR_OS(responseptr, &m->omsg.h.numAdditionals, &nsec.resrec);
2930 if (newptr) responseptr = newptr;
2931 }
2932 }
2933 else LogMsg("SendResponses: not enough space (%d) in authrecord for nsec", nsec.resrec.rdlength);
2934
2935 // If we successfully put the NSEC record, clear the SendNSECNow flag
2936 // If we consider this NSEC optional, then we unconditionally clear the SendNSECNow flag, even if we fail to put this additional record
2937 if (newptr || rr->SendNSECNow == mDNSInterfaceMark)
2938 {
2939 rr->SendNSECNow = mDNSNULL;
2940 // Run through remainder of list clearing SendNSECNow flag for all other records which would generate the same NSEC
2941 for (r2 = rr->next; r2; r2=r2->next)
2942 if (SameResourceRecordNameClassInterface(r2, rr))
2943 if (r2->SendNSECNow == mDNSInterfaceMark || r2->SendNSECNow == intf->InterfaceID)
2944 r2->SendNSECNow = mDNSNULL;
2945 }
2946 }
2947
2948 if (m->omsg.h.numAnswers || m->omsg.h.numAdditionals)
2949 {
2950 // If we have data to send, add OWNER/TRACER/OWNER+TRACER option if necessary, then send packet
2951 if (OwnerRecordSpace || TraceRecordSpace)
2952 {
2953 AuthRecord opt;
2954 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
2955 opt.resrec.rrclass = NormalMaxDNSMessageData;
2956 opt.resrec.rdlength = sizeof(rdataOPT);
2957 opt.resrec.rdestimate = sizeof(rdataOPT);
2958 if (OwnerRecordSpace && TraceRecordSpace)
2959 {
2960 opt.resrec.rdlength += sizeof(rdataOPT); // Two options in this OPT record
2961 opt.resrec.rdestimate += sizeof(rdataOPT);
2962 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]);
2963 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[1]);
2964 }
2965 else if (OwnerRecordSpace)
2966 {
2967 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]);
2968 }
2969 else if (TraceRecordSpace)
2970 {
2971 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[0]);
2972 }
2973 newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &opt.resrec);
2974 if (newptr)
2975 {
2976 responseptr = newptr;
2977 }
2978 else if (m->omsg.h.numAnswers + m->omsg.h.numAuthorities + m->omsg.h.numAdditionals == 1)
2979 {
2980 LogInfo("SendResponses: No space in packet for %s %s OPT record (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", TraceRecordSpace ? "TRACER" : "",
2981 m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt));
2982 }
2983 else
2984 {
2985 LogMsg("SendResponses: How did we fail to have space for %s %s OPT record (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", TraceRecordSpace ? "TRACER" : "",
2986 m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt));
2987 }
2988 }
2989
2990 debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p",
2991 numDereg, numDereg == 1 ? "" : "s",
2992 numAnnounce, numAnnounce == 1 ? "" : "s",
2993 numAnswer, numAnswer == 1 ? "" : "s",
2994 m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID);
2995
2996 if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse);
2997 if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse);
2998 if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10);
2999 if (++pktcount >= 1000) { LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount); break; }
3000 // There might be more things to send on this interface, so go around one more time and try again.
3001 }
3002 else // Nothing more to send on this interface; go to next
3003 {
3004 const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
3005 #if MDNS_DEBUGMSGS && 0
3006 const char *const msg = next ? "SendResponses: Nothing more on %p; moving to %p" : "SendResponses: Nothing more on %p";
3007 debugf(msg, intf, next);
3008 #endif
3009 intf = next;
3010 pktcount = 0; // When we move to a new interface, reset packet count back to zero -- NSEC generation logic uses it
3011 }
3012 }
3013
3014 // ***
3015 // *** 3. Cleanup: Now that everything is sent, call client callback functions, and reset state variables
3016 // ***
3017
3018 if (m->CurrentRecord)
3019 LogMsg("SendResponses ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
3020 m->CurrentRecord = m->ResourceRecords;
3021 while (m->CurrentRecord)
3022 {
3023 rr = m->CurrentRecord;
3024 m->CurrentRecord = rr->next;
3025
3026 if (rr->SendRNow)
3027 {
3028 if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P)
3029 LogInfo("SendResponses: No active interface %d to send: %d %02X %s",
3030 IID(rr->SendRNow), IID(rr->resrec.InterfaceID), rr->resrec.RecordType, ARDisplayString(m, rr));
3031 rr->SendRNow = mDNSNULL;
3032 }
3033
3034 if (rr->ImmedAnswer || rr->resrec.RecordType == kDNSRecordTypeDeregistering)
3035 {
3036 if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client
3037
3038 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering && rr->AnnounceCount == 0)
3039 {
3040 // For Unicast, when we get the response from the server, we will call CompleteDeregistration
3041 if (!AuthRecord_uDNS(rr)) CompleteDeregistration(m, rr); // Don't touch rr after this
3042 }
3043 else
3044 {
3045 rr->ImmedAnswer = mDNSNULL;
3046 rr->ImmedUnicast = mDNSfalse;
3047 rr->v4Requester = zerov4Addr;
3048 rr->v6Requester = zerov6Addr;
3049 }
3050 }
3051 }
3052 verbosedebugf("SendResponses: Next in %ld ticks", m->NextScheduledResponse - m->timenow);
3053}
3054
3055// Calling CheckCacheExpiration() is an expensive operation because it has to look at the entire cache,
3056// so we want to be lazy about how frequently we do it.
3057// 1. If a cache record is currently referenced by *no* active questions,
3058// then we don't mind expiring it up to a minute late (who will know?)
3059// 2. Else, if a cache record is due for some of its final expiration queries,
3060// we'll allow them to be late by up to 2% of the TTL
3061// 3. Else, if a cache record has completed all its final expiration queries without success,
3062// and is expiring, and had an original TTL more than ten seconds, we'll allow it to be one second late
3063// 4. Else, it is expiring and had an original TTL of ten seconds or less (includes explicit goodbye packets),
3064// so allow at most 1/10 second lateness
3065// 5. For records with rroriginalttl set to zero, that means we really want to delete them immediately
3066// (we have a new record with DelayDelivery set, waiting for the old record to go away before we can notify clients).
3067#define CacheCheckGracePeriod(RR) ( \
3068 ((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \
3069 ((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \
3070 ((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : \
3071 ((RR)->resrec.rroriginalttl > 0 ) ? (mDNSPlatformOneSecond/10) : 0)
3072
3073#define NextCacheCheckEvent(RR) ((RR)->NextRequiredQuery + CacheCheckGracePeriod(RR))
3074
3075mDNSexport void ScheduleNextCacheCheckTime(mDNS *const m, const mDNSu32 slot, const mDNSs32 event)
3076{
3077 if (m->rrcache_nextcheck[slot] - event > 0)
3078 m->rrcache_nextcheck[slot] = event;
3079 if (m->NextCacheCheck - event > 0)
3080 m->NextCacheCheck = event;
3081}
3082
3083// Note: MUST call SetNextCacheCheckTimeForRecord any time we change:
3084// rr->TimeRcvd
3085// rr->resrec.rroriginalttl
3086// rr->UnansweredQueries
3087// rr->CRActiveQuestion
3088mDNSexport void SetNextCacheCheckTimeForRecord(mDNS *const m, CacheRecord *const rr)
3089{
3090 rr->NextRequiredQuery = RRExpireTime(rr);
3091
3092 // If we have an active question, then see if we want to schedule a refresher query for this record.
3093 // Usually we expect to do four queries, at 80-82%, 85-87%, 90-92% and then 95-97% of the TTL.
3094 if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
3095 {
3096 rr->NextRequiredQuery -= TicksTTL(rr)/20 * (MaxUnansweredQueries - rr->UnansweredQueries);
3097 rr->NextRequiredQuery += mDNSRandom((mDNSu32)TicksTTL(rr)/50);
3098 verbosedebugf("SetNextCacheCheckTimeForRecord: NextRequiredQuery in %ld sec CacheCheckGracePeriod %d ticks for %s",
3099 (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m,rr));
3100 }
3101 ScheduleNextCacheCheckTime(m, HashSlotFromNameHash(rr->resrec.namehash), NextCacheCheckEvent(rr));
3102}
3103
3104#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
3105#define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5)
3106#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5)
3107
3108// Delay before restarting questions on a flapping interface.
3109#define kDefaultQueryDelayTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 3)
3110// After kDefaultQueryDelayTimeForFlappingInterface seconds, allow enough time for up to three queries (0, 1, and 4 seconds)
3111// plus three seconds for "response delay" before removing the reconfirmed records from the cache.
3112#define kDefaultReconfirmTimeForFlappingInterface (kDefaultQueryDelayTimeForFlappingInterface + ((mDNSu32)mDNSPlatformOneSecond * 7))
3113
3114mDNSexport mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval)
3115{
3116 if (interval < kMinimumReconfirmTime)
3117 interval = kMinimumReconfirmTime;
3118 if (interval > 0x10000000) // Make sure interval doesn't overflow when we multiply by four below
3119 interval = 0x10000000;
3120
3121 // If the expected expiration time for this record is more than interval+33%, then accelerate its expiration
3122 if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3))
3123 {
3124 // Add a 33% random amount to the interval, to avoid synchronization between multiple hosts
3125 // For all the reconfirmations in a given batch, we want to use the same random value
3126 // so that the reconfirmation questions can be grouped into a single query packet
3127 if (!m->RandomReconfirmDelay) m->RandomReconfirmDelay = 1 + mDNSRandom(FutureTime);
3128 interval += m->RandomReconfirmDelay % ((interval/3) + 1);
3129 rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3;
3130 rr->resrec.rroriginalttl = (interval * 4 + mDNSPlatformOneSecond - 1) / mDNSPlatformOneSecond;
3131 SetNextCacheCheckTimeForRecord(m, rr);
3132 }
3133 debugf("mDNS_Reconfirm_internal:%6ld ticks to go for %s %p",
3134 RRExpireTime(rr) - m->timenow, CRDisplayString(m, rr), rr->CRActiveQuestion);
3135 return(mStatus_NoError);
3136}
3137
3138// BuildQuestion puts a question into a DNS Query packet and if successful, updates the value of queryptr.
3139// It also appends to the list of known answer records that need to be included,
3140// and updates the forcast for the size of the known answer section.
3141mDNSlocal mDNSBool BuildQuestion(mDNS *const m, const NetworkInterfaceInfo *intf, DNSMessage *query, mDNSu8 **queryptr,
3142 DNSQuestion *q, CacheRecord ***kalistptrptr, mDNSu32 *answerforecast)
3143{
3144 mDNSBool ucast = (q->LargeAnswers || q->RequestUnicast) && m->CanReceiveUnicastOn5353 && intf->SupportsUnicastMDNSResponse;
3145 mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
3146 const mDNSu8 *const limit = query->data + NormalMaxDNSMessageData;
3147 mDNSu8 anoninfo_space = q->AnonInfo ? AnonInfoSpace(q->AnonInfo) : 0;
3148 mDNSu8 *newptr = putQuestion(query, *queryptr, limit - *answerforecast - anoninfo_space, &q->qname, q->qtype, (mDNSu16)(q->qclass | ucbit));
3149 if (!newptr)
3150 {
3151 debugf("BuildQuestion: No more space in this packet for question %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
3152 return(mDNSfalse);
3153 }
3154 else
3155 {
3156 mDNSu32 forecast = *answerforecast + anoninfo_space;
3157 const CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
3158 CacheRecord *rr;
3159 CacheRecord **ka = *kalistptrptr; // Make a working copy of the pointer we're going to update
3160
3161 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache,
3162 if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface
3163 !(rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && // which is a shared (i.e. not unique) record type
3164 rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not already in the known answer list
3165 rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet
3166 SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question
3167 rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow > // and its half-way-to-expiry time is at least 1 second away
3168 mDNSPlatformOneSecond) // (also ensures we never include goodbye records with TTL=1)
3169 {
3170 // We don't want to include unique records in the Known Answer section. The Known Answer section
3171 // is intended to suppress floods of shared-record replies from many other devices on the network.
3172 // That concept really does not apply to unique records, and indeed if we do send a query for
3173 // which we have a unique record already in our cache, then including that unique record as a
3174 // Known Answer, so as to suppress the only answer we were expecting to get, makes little sense.
3175
3176 *ka = rr; // Link this record into our known answer chain
3177 ka = &rr->NextInKAList;
3178 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
3179 forecast += 12 + rr->resrec.rdestimate;
3180 // If we're trying to put more than one question in this packet, and it doesn't fit
3181 // then undo that last question and try again next time
3182 if (query->h.numQuestions > 1 && newptr + forecast >= limit)
3183 {
3184 query->h.numQuestions--;
3185 debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d, total questions %d",
3186 q->qname.c, DNSTypeName(q->qtype), newptr + forecast - query->data, query->h.numQuestions);
3187 ka = *kalistptrptr; // Go back to where we started and retract these answer records
3188 while (*ka) { CacheRecord *c = *ka; *ka = mDNSNULL; ka = &c->NextInKAList; }
3189 return(mDNSfalse); // Return false, so we'll try again in the next packet
3190 }
3191 }
3192
3193 // Success! Update our state pointers, increment UnansweredQueries as appropriate, and return
3194 *queryptr = newptr; // Update the packet pointer
3195 *answerforecast = forecast; // Update the forecast
3196 *kalistptrptr = ka; // Update the known answer list pointer
3197 if (ucast) q->ExpectUnicastResp = NonZeroTime(m->timenow);
3198
3199 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // For every resource record in our cache,
3200 if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface
3201 rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not in the known answer list
3202 SameNameRecordAnswersQuestion(&rr->resrec, q)) // which answers our question
3203 {
3204 rr->UnansweredQueries++; // indicate that we're expecting a response
3205 rr->LastUnansweredTime = m->timenow;
3206 SetNextCacheCheckTimeForRecord(m, rr);
3207 }
3208
3209 return(mDNStrue);
3210 }
3211}
3212
3213// When we have a query looking for a specified name, but there appear to be no answers with
3214// that name, ReconfirmAntecedents() is called with depth=0 to start the reconfirmation process
3215// for any records in our cache that reference the given name (e.g. PTR and SRV records).
3216// For any such cache record we find, we also recursively call ReconfirmAntecedents() for *its* name.
3217// We increment depth each time we recurse, to guard against possible infinite loops, with a limit of 5.
3218// A typical reconfirmation scenario might go like this:
3219// Depth 0: Name "myhost.local" has no address records
3220// Depth 1: SRV "My Service._example._tcp.local." refers to "myhost.local"; may be stale
3221// Depth 2: PTR "_example._tcp.local." refers to "My Service"; may be stale
3222// Depth 3: PTR "_services._dns-sd._udp.local." refers to "_example._tcp.local."; may be stale
3223// Currently depths 4 and 5 are not expected to occur; if we did get to depth 5 we'd reconfim any records we
3224// found referring to the given name, but not recursively descend any further reconfirm *their* antecedents.
3225mDNSlocal void ReconfirmAntecedents(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const int depth)
3226{
3227 mDNSu32 slot;
3228 CacheGroup *cg;
3229 CacheRecord *cr;
3230 debugf("ReconfirmAntecedents (depth=%d) for %##s", depth, name->c);
3231 FORALL_CACHERECORDS(slot, cg, cr)
3232 {
3233 domainname *crtarget = GetRRDomainNameTarget(&cr->resrec);
3234 if (crtarget && cr->resrec.rdatahash == namehash && SameDomainName(crtarget, name))
3235 {
3236 LogInfo("ReconfirmAntecedents: Reconfirming (depth=%d) %s", depth, CRDisplayString(m, cr));
3237 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
3238 if (depth < 5)
3239 ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, depth+1);
3240 }
3241 }
3242}
3243
3244// If we get no answer for a AAAA query, then before doing an automatic implicit ReconfirmAntecedents
3245// we check if we have an address record for the same name. If we do have an IPv4 address for a given
3246// name but not an IPv6 address, that's okay (it just means the device doesn't do IPv6) so the failure
3247// to get a AAAA response is not grounds to doubt the PTR/SRV chain that lead us to that name.
3248mDNSlocal const CacheRecord *CacheHasAddressTypeForName(mDNS *const m, const domainname *const name, const mDNSu32 namehash)
3249{
3250 CacheGroup *const cg = CacheGroupForName(m, namehash, name);
3251 const CacheRecord *cr = cg ? cg->members : mDNSNULL;
3252 while (cr && !RRTypeIsAddressType(cr->resrec.rrtype)) cr=cr->next;
3253 return(cr);
3254}
3255
3256
3257mDNSlocal const CacheRecord *FindSPSInCache1(mDNS *const m, const DNSQuestion *const q, const CacheRecord *const c0, const CacheRecord *const c1)
3258{
3259#ifndef SPC_DISABLED
3260 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
3261 const CacheRecord *cr, *bestcr = mDNSNULL;
3262 mDNSu32 bestmetric = 1000000;
3263 for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next)
3264 if (cr->resrec.rrtype == kDNSType_PTR && cr->resrec.rdlength >= 6) // If record is PTR type, with long enough name,
3265 if (cr != c0 && cr != c1) // that's not one we've seen before,
3266 if (SameNameRecordAnswersQuestion(&cr->resrec, q)) // and answers our browse query,
3267 if (!IdenticalSameNameRecord(&cr->resrec, &m->SPSRecords.RR_PTR.resrec)) // and is not our own advertised service...
3268 {
3269 mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c);
3270 if (bestmetric > metric) { bestmetric = metric; bestcr = cr; }
3271 }
3272 return(bestcr);
3273#else // SPC_DISABLED
3274 (void) m;
3275 (void) q;
3276 (void) c0;
3277 (void) c1;
3278 (void) c1;
3279 return mDNSNULL;
3280#endif // SPC_DISABLED
3281}
3282
3283mDNSlocal void CheckAndSwapSPS(const CacheRecord **sps1, const CacheRecord **sps2)
3284{
3285 const CacheRecord *swap_sps;
3286 mDNSu32 metric1, metric2;
3287
3288 if (!(*sps1) || !(*sps2)) return;
3289 metric1 = SPSMetric((*sps1)->resrec.rdata->u.name.c);
3290 metric2 = SPSMetric((*sps2)->resrec.rdata->u.name.c);
3291 if (!SPSFeatures((*sps1)->resrec.rdata->u.name.c) && SPSFeatures((*sps2)->resrec.rdata->u.name.c) && (metric2 >= metric1))
3292 {
3293 swap_sps = *sps1;
3294 *sps1 = *sps2;
3295 *sps2 = swap_sps;
3296 }
3297}
3298
3299mDNSlocal void ReorderSPSByFeature(const CacheRecord *sps[3])
3300{
3301 CheckAndSwapSPS(&sps[0], &sps[1]);
3302 CheckAndSwapSPS(&sps[0], &sps[2]);
3303 CheckAndSwapSPS(&sps[1], &sps[2]);
3304}
3305
3306
3307// Finds the three best Sleep Proxies we currently have in our cache
3308mDNSexport void FindSPSInCache(mDNS *const m, const DNSQuestion *const q, const CacheRecord *sps[3])
3309{
3310 sps[0] = FindSPSInCache1(m, q, mDNSNULL, mDNSNULL);
3311 sps[1] = !sps[0] ? mDNSNULL : FindSPSInCache1(m, q, sps[0], mDNSNULL);
3312 sps[2] = !sps[1] ? mDNSNULL : FindSPSInCache1(m, q, sps[0], sps[1]);
3313
3314 // SPS is already sorted by metric. We want to move the entries to the beginning of the array
3315 // only if they have equally good metric and support features.
3316 ReorderSPSByFeature(sps);
3317}
3318
3319// Only DupSuppressInfos newer than the specified 'time' are allowed to remain active
3320mDNSlocal void ExpireDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time)
3321{
3322 int i;
3323 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL;
3324}
3325
3326mDNSlocal void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time, mDNSInterfaceID InterfaceID)
3327{
3328 int i;
3329 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL;
3330}
3331
3332mDNSlocal mDNSBool SuppressOnThisInterface(const DupSuppressInfo ds[DupSuppressInfoSize], const NetworkInterfaceInfo * const intf)
3333{
3334 int i;
3335 mDNSBool v4 = !intf->IPv4Available; // If this interface doesn't do v4, we don't need to find a v4 duplicate of this query
3336 mDNSBool v6 = !intf->IPv6Available; // If this interface doesn't do v6, we don't need to find a v6 duplicate of this query
3337 for (i=0; i<DupSuppressInfoSize; i++)
3338 if (ds[i].InterfaceID == intf->InterfaceID)
3339 {
3340 if (ds[i].Type == mDNSAddrType_IPv4) v4 = mDNStrue;
3341 else if (ds[i].Type == mDNSAddrType_IPv6) v6 = mDNStrue;
3342 if (v4 && v6) return(mDNStrue);
3343 }
3344 return(mDNSfalse);
3345}
3346
3347mDNSlocal void RecordDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 Time, mDNSInterfaceID InterfaceID, mDNSs32 Type)
3348{
3349 int i, j;
3350
3351 // See if we have this one in our list somewhere already
3352 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Type == Type) break;
3353
3354 // If not, find a slot we can re-use
3355 if (i >= DupSuppressInfoSize)
3356 {
3357 i = 0;
3358 for (j=1; j<DupSuppressInfoSize && ds[i].InterfaceID; j++)
3359 if (!ds[j].InterfaceID || ds[j].Time - ds[i].Time < 0)
3360 i = j;
3361 }
3362
3363 // Record the info about this query we saw
3364 ds[i].Time = Time;
3365 ds[i].InterfaceID = InterfaceID;
3366 ds[i].Type = Type;
3367}
3368
3369mDNSlocal void mDNSSendWakeOnResolve(mDNS *const m, DNSQuestion *q)
3370{
3371 int len, i, cnt;
3372 mDNSInterfaceID InterfaceID = q->InterfaceID;
3373 domainname *d = &q->qname;
3374
3375 // We can't send magic packets without knowing which interface to send it on.
3376 if (InterfaceID == mDNSInterface_Any || LocalOnlyOrP2PInterface(InterfaceID))
3377 {
3378 LogMsg("mDNSSendWakeOnResolve: ERROR!! Invalid InterfaceID %p for question %##s", InterfaceID, q->qname.c);
3379 return;
3380 }
3381
3382 // Split MAC@IPAddress and pass them separately
3383 len = d->c[0];
3384 cnt = 0;
3385 for (i = 1; i < len; i++)
3386 {
3387 if (d->c[i] == '@')
3388 {
3389 char EthAddr[18]; // ethernet adddress : 12 bytes + 5 ":" + 1 NULL byte
3390 char IPAddr[47]; // Max IP address len: 46 bytes (IPv6) + 1 NULL byte
3391 if (cnt != 5)
3392 {
3393 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, cnt %d", q->qname.c, cnt);
3394 return;
3395 }
3396 if ((i - 1) > (int) (sizeof(EthAddr) - 1))
3397 {
3398 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, length %d", q->qname.c, i - 1);
3399 return;
3400 }
3401 if ((len - i) > (int)(sizeof(IPAddr) - 1))
3402 {
3403 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed IP address %##s, length %d", q->qname.c, len - i);
3404 return;
3405 }
3406 mDNSPlatformMemCopy(EthAddr, &d->c[1], i - 1);
3407 EthAddr[i - 1] = 0;
3408 mDNSPlatformMemCopy(IPAddr, &d->c[i + 1], len - i);
3409 IPAddr[len - i] = 0;
3410 m->mDNSStats.WakeOnResolves++;
3411 mDNSPlatformSendWakeupPacket(InterfaceID, EthAddr, IPAddr, InitialWakeOnResolveCount - q->WakeOnResolveCount);
3412 return;
3413 }
3414 else if (d->c[i] == ':')
3415 cnt++;
3416 }
3417 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed WakeOnResolve name %##s", q->qname.c);
3418}
3419
3420
3421mDNSlocal mDNSBool AccelerateThisQuery(mDNS *const m, DNSQuestion *q)
3422{
3423 // If more than 90% of the way to the query time, we should unconditionally accelerate it
3424 if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/10))
3425 return(mDNStrue);
3426
3427 // If half-way to next scheduled query time, only accelerate if it will add less than 512 bytes to the packet
3428 if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/2))
3429 {
3430 // We forecast: qname (n) type (2) class (2)
3431 mDNSu32 forecast = (mDNSu32)DomainNameLength(&q->qname) + 4;
3432 const CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
3433 const CacheRecord *rr;
3434 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache,
3435 if (rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet
3436 SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question
3437 rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && // and it is less than half-way to expiry
3438 rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0) // and we'll ask at least once again before NextRequiredQuery
3439 {
3440 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
3441 forecast += 12 + rr->resrec.rdestimate;
3442 if (forecast >= 512) return(mDNSfalse); // If this would add 512 bytes or more to the packet, don't accelerate
3443 }
3444 return(mDNStrue);
3445 }
3446
3447 return(mDNSfalse);
3448}
3449
3450// How Standard Queries are generated:
3451// 1. The Question Section contains the question
3452// 2. The Additional Section contains answers we already know, to suppress duplicate responses
3453
3454// How Probe Queries are generated:
3455// 1. The Question Section contains queries for the name we intend to use, with QType=ANY because
3456// if some other host is already using *any* records with this name, we want to know about it.
3457// 2. The Authority Section contains the proposed values we intend to use for one or more
3458// of our records with that name (analogous to the Update section of DNS Update packets)
3459// because if some other host is probing at the same time, we each want to know what the other is
3460// planning, in order to apply the tie-breaking rule to see who gets to use the name and who doesn't.
3461
3462mDNSlocal void SendQueries(mDNS *const m)
3463{
3464 mDNSu32 slot;
3465 CacheGroup *cg;
3466 CacheRecord *cr;
3467 AuthRecord *ar;
3468 int pktcount = 0;
3469 DNSQuestion *q;
3470 // For explanation of maxExistingQuestionInterval logic, see comments for maxExistingAnnounceInterval
3471 mDNSs32 maxExistingQuestionInterval = 0;
3472 const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
3473 CacheRecord *KnownAnswerList = mDNSNULL;
3474
3475 // 1. If time for a query, work out what we need to do
3476
3477 // We're expecting to send a query anyway, so see if any expiring cache records are close enough
3478 // to their NextRequiredQuery to be worth batching them together with this one
3479 FORALL_CACHERECORDS(slot, cg, cr)
3480 {
3481 if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries)
3482 {
3483 if (m->timenow + TicksTTL(cr)/50 - cr->NextRequiredQuery >= 0)
3484 {
3485 debugf("Sending %d%% cache expiration query for %s", 80 + 5 * cr->UnansweredQueries, CRDisplayString(m, cr));
3486 q = cr->CRActiveQuestion;
3487 ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(cr)/20, cr->resrec.InterfaceID);
3488 // For uDNS queries (TargetQID non-zero) we adjust LastQTime,
3489 // and bump UnansweredQueries so that we don't spin trying to send the same cache expiration query repeatedly
3490 if (q->Target.type)
3491 {
3492 q->SendQNow = mDNSInterfaceMark; // If targeted query, mark it
3493 }
3494 else if (!mDNSOpaque16IsZero(q->TargetQID))
3495 {
3496 q->LastQTime = m->timenow - q->ThisQInterval;
3497 cr->UnansweredQueries++;
3498 m->mDNSStats.CacheRefreshQueries++;
3499 }
3500 else if (q->SendQNow == mDNSNULL)
3501 {
3502 q->SendQNow = cr->resrec.InterfaceID;
3503 }
3504 else if (q->SendQNow != cr->resrec.InterfaceID)
3505 {
3506 q->SendQNow = mDNSInterfaceMark;
3507 }
3508
3509 // Indicate that this question was marked for sending
3510 // to update an existing cached answer record.
3511 // The browse throttling logic below uses this to determine
3512 // if the query should be sent.
3513 if (mDNSOpaque16IsZero(q->TargetQID))
3514 q->CachedAnswerNeedsUpdate = mDNStrue;
3515 }
3516 }
3517 }
3518
3519 // Scan our list of questions to see which:
3520 // *WideArea* queries need to be sent
3521 // *unicast* queries need to be sent
3522 // *multicast* queries we're definitely going to send
3523 if (m->CurrentQuestion)
3524 LogMsg("SendQueries ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
3525 m->CurrentQuestion = m->Questions;
3526 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
3527 {
3528 q = m->CurrentQuestion;
3529 if (q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow)))
3530 {
3531 mDNSu8 *qptr = m->omsg.data;
3532 const mDNSu8 *const limit = m->omsg.data + sizeof(m->omsg.data);
3533
3534 // If we fail to get a new on-demand socket (should only happen cases of the most extreme resource exhaustion), we'll try again next time
3535 if (!q->LocalSocket) q->LocalSocket = mDNSPlatformUDPSocket(zeroIPPort);
3536 if (q->LocalSocket)
3537 {
3538 InitializeDNSMessage(&m->omsg.h, q->TargetQID, QueryFlags);
3539 qptr = putQuestion(&m->omsg, qptr, limit, &q->qname, q->qtype, q->qclass);
3540 mDNSSendDNSMessage(m, &m->omsg, qptr, mDNSInterface_Any, q->LocalSocket, &q->Target, q->TargetPort, mDNSNULL, mDNSNULL, q->UseBackgroundTrafficClass);
3541 q->ThisQInterval *= QuestionIntervalStep;
3542 }
3543 if (q->ThisQInterval > MaxQuestionInterval)
3544 q->ThisQInterval = MaxQuestionInterval;
3545 q->LastQTime = m->timenow;
3546 q->LastQTxTime = m->timenow;
3547 q->RecentAnswerPkts = 0;
3548 q->SendQNow = mDNSNULL;
3549 q->ExpectUnicastResp = NonZeroTime(m->timenow);
3550 }
3551 else if (mDNSOpaque16IsZero(q->TargetQID) && !q->Target.type && TimeToSendThisQuestion(q, m->timenow))
3552 {
3553 //LogInfo("Time to send %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - NextQSendTime(q));
3554 q->SendQNow = mDNSInterfaceMark; // Mark this question for sending on all interfaces
3555 if (maxExistingQuestionInterval < q->ThisQInterval)
3556 maxExistingQuestionInterval = q->ThisQInterval;
3557 }
3558 // If m->CurrentQuestion wasn't modified out from under us, advance it now
3559 // We can't do this at the start of the loop because uDNS_CheckCurrentQuestion() depends on having
3560 // m->CurrentQuestion point to the right question
3561 if (q == m->CurrentQuestion) m->CurrentQuestion = m->CurrentQuestion->next;
3562 }
3563 while (m->CurrentQuestion)
3564 {
3565 LogInfo("SendQueries question loop 1: Skipping NewQuestion %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
3566 m->CurrentQuestion = m->CurrentQuestion->next;
3567 }
3568 m->CurrentQuestion = mDNSNULL;
3569
3570 // Scan our list of questions
3571 // (a) to see if there are any more that are worth accelerating, and
3572 // (b) to update the state variables for *all* the questions we're going to send
3573 // Note: Don't set NextScheduledQuery until here, because uDNS_CheckCurrentQuestion in the loop above can add new questions to the list,
3574 // which causes NextScheduledQuery to get (incorrectly) set to m->timenow. Setting it here is the right place, because the very
3575 // next thing we do is scan the list and call SetNextQueryTime() for every question we find, so we know we end up with the right value.
3576 m->NextScheduledQuery = m->timenow + FutureTime;
3577 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
3578 {
3579 if (mDNSOpaque16IsZero(q->TargetQID)
3580 && (q->SendQNow || (!q->Target.type && ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q))))
3581 {
3582 // If at least halfway to next query time, advance to next interval
3583 // If less than halfway to next query time, then
3584 // treat this as logically a repeat of the last transmission, without advancing the interval
3585 if (m->timenow - (q->LastQTime + (q->ThisQInterval/2)) >= 0)
3586 {
3587 // If we have reached the answer threshold for this question,
3588 // don't send it again until MaxQuestionInterval unless:
3589 // one of its cached answers needs to be refreshed,
3590 // or it's the initial query for a kDNSServiceFlagsThresholdFinder mode browse.
3591 if (q->BrowseThreshold
3592 && (q->CurrentAnswers >= q->BrowseThreshold)
3593 && (q->CachedAnswerNeedsUpdate == mDNSfalse)
3594 && !((q->flags & kDNSServiceFlagsThresholdFinder) && (q->ThisQInterval == InitialQuestionInterval)))
3595 {
3596 q->SendQNow = mDNSNULL;
3597 q->ThisQInterval = MaxQuestionInterval;
3598 q->LastQTime = m->timenow;
3599 q->RequestUnicast = 0;
3600 LogInfo("SendQueries: (%s) %##s reached threshold of %d answers",
3601 DNSTypeName(q->qtype), q->qname.c, q->BrowseThreshold);
3602 }
3603 else
3604 {
3605 // Mark this question for sending on all interfaces
3606 q->SendQNow = mDNSInterfaceMark;
3607 q->ThisQInterval *= QuestionIntervalStep;
3608 }
3609
3610 debugf("SendQueries: %##s (%s) next interval %d seconds RequestUnicast = %d",
3611 q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval / InitialQuestionInterval, q->RequestUnicast);
3612
3613 if (q->ThisQInterval > MaxQuestionInterval)
3614 {
3615 q->ThisQInterval = MaxQuestionInterval;
3616 }
3617 else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * QuestionIntervalStep3 && !q->RequestUnicast &&
3618 !(RRTypeIsAddressType(q->qtype) && CacheHasAddressTypeForName(m, &q->qname, q->qnamehash)))
3619 {
3620 // Generally don't need to log this.
3621 // It's not especially noteworthy if a query finds no results -- this usually happens for domain
3622 // enumeration queries in the LL subdomain (e.g. "db._dns-sd._udp.0.0.254.169.in-addr.arpa")
3623 // and when there simply happen to be no instances of the service the client is looking
3624 // for (e.g. iTunes is set to look for RAOP devices, and the current network has none).
3625 debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents",
3626 q->qname.c, DNSTypeName(q->qtype));
3627 // Sending third query, and no answers yet; time to begin doubting the source
3628 ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0);
3629 }
3630 }
3631
3632 // Mark for sending. (If no active interfaces, then don't even try.)
3633 q->SendOnAll = (q->SendQNow == mDNSInterfaceMark);
3634 if (q->SendOnAll)
3635 {
3636 q->SendQNow = !intf ? mDNSNULL : (q->InterfaceID) ? q->InterfaceID : intf->InterfaceID;
3637 q->LastQTime = m->timenow;
3638 }
3639
3640 // If we recorded a duplicate suppression for this question less than half an interval ago,
3641 // then we consider it recent enough that we don't need to do an identical query ourselves.
3642 ExpireDupSuppressInfo(q->DupSuppress, m->timenow - q->ThisQInterval/2);
3643
3644 q->LastQTxTime = m->timenow;
3645 q->RecentAnswerPkts = 0;
3646 if (q->RequestUnicast) q->RequestUnicast--;
3647 }
3648 // For all questions (not just the ones we're sending) check what the next scheduled event will be
3649 // We don't need to consider NewQuestions here because for those we'll set m->NextScheduledQuery in AnswerNewQuestion
3650 SetNextQueryTime(m,q);
3651 }
3652
3653 // 2. Scan our authoritative RR list to see what probes we might need to send
3654
3655 m->NextScheduledProbe = m->timenow + FutureTime;
3656
3657 if (m->CurrentRecord)
3658 LogMsg("SendQueries ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
3659 m->CurrentRecord = m->ResourceRecords;
3660 while (m->CurrentRecord)
3661 {
3662 ar = m->CurrentRecord;
3663 m->CurrentRecord = ar->next;
3664 if (!AuthRecord_uDNS(ar) && ar->resrec.RecordType == kDNSRecordTypeUnique) // For all records that are still probing...
3665 {
3666 // 1. If it's not reached its probe time, just make sure we update m->NextScheduledProbe correctly
3667 if (m->timenow - (ar->LastAPTime + ar->ThisAPInterval) < 0)
3668 {
3669 SetNextAnnounceProbeTime(m, ar);
3670 }
3671 // 2. else, if it has reached its probe time, mark it for sending and then update m->NextScheduledProbe correctly
3672 else if (ar->ProbeCount)
3673 {
3674 if (ar->AddressProxy.type == mDNSAddrType_IPv4)
3675 {
3676 // There's a problem here. If a host is waking up, and we probe to see if it responds, then
3677 // it will see those ARP probes as signalling intent to use the address, so it picks a different one.
3678 // A more benign way to find out if a host is responding to ARPs might be send a standard ARP *request*
3679 // (using our sender IP address) instead of an ARP *probe* (using all-zero sender IP address).
3680 // A similar concern may apply to the NDP Probe too. -- SC
3681 LogSPS("SendQueries ARP Probe %d %s %s", ar->ProbeCount, InterfaceNameForID(m, ar->resrec.InterfaceID), ARDisplayString(m,ar));
3682 SendARP(m, 1, ar, &zerov4Addr, &zeroEthAddr, &ar->AddressProxy.ip.v4, &ar->WakeUp.IMAC);
3683 }
3684 else if (ar->AddressProxy.type == mDNSAddrType_IPv6)
3685 {
3686 LogSPS("SendQueries NDP Probe %d %s %s", ar->ProbeCount, InterfaceNameForID(m, ar->resrec.InterfaceID), ARDisplayString(m,ar));
3687 // IPv6 source = zero
3688 // No target hardware address
3689 // IPv6 target address is address we're probing
3690 // Ethernet destination address is Ethernet interface address of the Sleep Proxy client we're probing
3691 SendNDP(m, NDP_Sol, 0, ar, &zerov6Addr, mDNSNULL, &ar->AddressProxy.ip.v6, &ar->WakeUp.IMAC);
3692 }
3693 // Mark for sending. (If no active interfaces, then don't even try.)
3694 ar->SendRNow = (!intf || ar->WakeUp.HMAC.l[0]) ? mDNSNULL : ar->resrec.InterfaceID ? ar->resrec.InterfaceID : intf->InterfaceID;
3695 ar->LastAPTime = m->timenow;
3696 // When we have a late conflict that resets a record to probing state we use a special marker value greater
3697 // than DefaultProbeCountForTypeUnique. Here we detect that state and reset ar->ProbeCount back to the right value.
3698 if (ar->ProbeCount > DefaultProbeCountForTypeUnique)
3699 ar->ProbeCount = DefaultProbeCountForTypeUnique;
3700 ar->ProbeCount--;
3701 SetNextAnnounceProbeTime(m, ar);
3702 if (ar->ProbeCount == 0)
3703 {
3704 // If this is the last probe for this record, then see if we have any matching records
3705 // on our duplicate list which should similarly have their ProbeCount cleared to zero...
3706 AuthRecord *r2;
3707 for (r2 = m->DuplicateRecords; r2; r2=r2->next)
3708 if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, ar))
3709 r2->ProbeCount = 0;
3710 // ... then acknowledge this record to the client.
3711 // We do this optimistically, just as we're about to send the third probe.
3712 // This helps clients that both advertise and browse, and want to filter themselves
3713 // from the browse results list, because it helps ensure that the registration
3714 // confirmation will be delivered 1/4 second *before* the browse "add" event.
3715 // A potential downside is that we could deliver a registration confirmation and then find out
3716 // moments later that there's a name conflict, but applications have to be prepared to handle
3717 // late conflicts anyway (e.g. on connection of network cable, etc.), so this is nothing new.
3718 if (!ar->Acknowledged) AcknowledgeRecord(m, ar);
3719 }
3720 }
3721 // else, if it has now finished probing, move it to state Verified,
3722 // and update m->NextScheduledResponse so it will be announced
3723 else
3724 {
3725 if (!ar->Acknowledged) AcknowledgeRecord(m, ar); // Defensive, just in case it got missed somehow
3726 ar->resrec.RecordType = kDNSRecordTypeVerified;
3727 ar->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique;
3728 ar->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique;
3729 SetNextAnnounceProbeTime(m, ar);
3730 }
3731 }
3732 }
3733 m->CurrentRecord = m->DuplicateRecords;
3734 while (m->CurrentRecord)
3735 {
3736 ar = m->CurrentRecord;
3737 m->CurrentRecord = ar->next;
3738 if (ar->resrec.RecordType == kDNSRecordTypeUnique && ar->ProbeCount == 0 && !ar->Acknowledged)
3739 AcknowledgeRecord(m, ar);
3740 }
3741
3742 // 3. Now we know which queries and probes we're sending,
3743 // go through our interface list sending the appropriate queries on each interface
3744 while (intf)
3745 {
3746 int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0;
3747 int TraceRecordSpace = (mDNS_McastTracingEnabled && MDNS_TRACER) ? DNSOpt_Header_Space + DNSOpt_TraceData_Space : 0;
3748 mDNSu8 *queryptr = m->omsg.data;
3749 mDNSBool useBackgroundTrafficClass = mDNSfalse; // set if we should use background traffic class
3750
3751 InitializeDNSMessage(&m->omsg.h, zeroID, QueryFlags);
3752 if (KnownAnswerList) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet");
3753 if (!KnownAnswerList)
3754 {
3755 // Start a new known-answer list
3756 CacheRecord **kalistptr = &KnownAnswerList;
3757 mDNSu32 answerforecast = OwnerRecordSpace + TraceRecordSpace; // Start by assuming we'll need at least enough space to put the Owner+Tracer Option
3758
3759 // Put query questions in this packet
3760 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
3761 {
3762 if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow == intf->InterfaceID))
3763 {
3764 mDNSBool Suppress = mDNSfalse;
3765 debugf("SendQueries: %s question for %##s (%s) at %d forecast total %d",
3766 SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting ",
3767 q->qname.c, DNSTypeName(q->qtype), queryptr - m->omsg.data, queryptr + answerforecast - m->omsg.data);
3768
3769 // If interface is P2P type, verify that query should be sent over it.
3770 if (!mDNSPlatformValidQuestionForInterface(q, intf))
3771 {
3772 q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf);
3773 }
3774 // If we're suppressing this question, or we successfully put it, update its SendQNow state
3775 else if ((Suppress = SuppressOnThisInterface(q->DupSuppress, intf)) ||
3776 BuildQuestion(m, intf, &m->omsg, &queryptr, q, &kalistptr, &answerforecast))
3777 {
3778 // We successfully added the question to the packet. Make sure that
3779 // we also send the NSEC3 record if required. BuildQuestion accounted for
3780 // the space.
3781 //
3782 // Note: We don't suppress anonymous questions and hence Suppress should always
3783 // be zero.
3784
3785 if (Suppress)
3786 m->mDNSStats.DupQuerySuppressions++;
3787
3788 if (!Suppress && q->AnonInfo)
3789 {
3790 debugf("SendQueries: marking for question %##s, Suppress %d", q->qname.c, Suppress);
3791 q->AnonInfo->SendNow = intf->InterfaceID;
3792 }
3793 q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf);
3794 if (q->WakeOnResolveCount)
3795 {
3796 mDNSSendWakeOnResolve(m, q);
3797 q->WakeOnResolveCount--;
3798 }
3799
3800 // use background traffic class if any included question requires it
3801 if (q->UseBackgroundTrafficClass)
3802 {
3803 useBackgroundTrafficClass = mDNStrue;
3804 }
3805 }
3806 }
3807 }
3808
3809 // Put probe questions in this packet
3810 for (ar = m->ResourceRecords; ar; ar=ar->next)
3811 {
3812 if (ar->SendRNow != intf->InterfaceID)
3813 continue;
3814
3815 // If interface is a P2P variant, verify that the probe should be sent over it.
3816 if (!mDNSPlatformValidRecordForInterface(ar, intf->InterfaceID))
3817 {
3818 ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf);
3819 ar->IncludeInProbe = mDNSfalse;
3820 }
3821 else
3822 {
3823 mDNSBool ucast = (ar->ProbeCount >= DefaultProbeCountForTypeUnique-1) && m->CanReceiveUnicastOn5353 && intf->SupportsUnicastMDNSResponse;
3824 mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
3825 const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.numQuestions ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData);
3826 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
3827 mDNSu32 forecast = answerforecast + 12 + ar->resrec.rdestimate;
3828 mDNSBool putProbe = mDNStrue;
3829 mDNSu16 qclass = ar->resrec.rrclass | ucbit;
3830
3831 {// Determine if this probe question is already in packet's dns message
3832 const mDNSu8 *questionptr = m->omsg.data;
3833 DNSQuestion question;
3834 mDNSu16 n;
3835 for (n = 0; n < m->omsg.h.numQuestions && questionptr; n++)
3836 {
3837 questionptr = getQuestion(&m->omsg, questionptr, limit, mDNSInterface_Any, &question);
3838 if (questionptr && (question.qtype == kDNSQType_ANY) && (question.qclass == qclass) &&
3839 (question.qnamehash == ar->resrec.namehash) && SameDomainName(&question.qname, ar->resrec.name))
3840 {
3841 putProbe = mDNSfalse; // set to false if already in message
3842 break;
3843 }
3844 }
3845 }
3846
3847 if (putProbe)
3848 {
3849 mDNSu8 *newptr = putQuestion(&m->omsg, queryptr, limit - forecast, ar->resrec.name, kDNSQType_ANY, qclass);
3850 if (newptr)
3851 {
3852 queryptr = newptr;
3853 answerforecast = forecast;
3854 ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf);
3855 ar->IncludeInProbe = mDNStrue;
3856 verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d InterfaceID= %d %d %d",
3857 ar->resrec.name->c, DNSTypeName(ar->resrec.rrtype), ar->ProbeCount, ar->resrec.InterfaceID, ar->resrec.rdestimate, answerforecast);
3858 }
3859 }
3860 else
3861 {
3862 ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf);
3863 ar->IncludeInProbe = mDNStrue;
3864 }
3865 }
3866 }
3867 }
3868
3869 // Put our known answer list (either new one from this question or questions, or remainder of old one from last time)
3870 while (KnownAnswerList)
3871 {
3872 CacheRecord *ka = KnownAnswerList;
3873 mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - ka->TimeRcvd)) / mDNSPlatformOneSecond;
3874 mDNSu8 *newptr = PutResourceRecordTTLWithLimit(&m->omsg, queryptr, &m->omsg.h.numAnswers, &ka->resrec, ka->resrec.rroriginalttl - SecsSinceRcvd,
3875 m->omsg.data + NormalMaxDNSMessageData - OwnerRecordSpace - TraceRecordSpace);
3876 if (newptr)
3877 {
3878 verbosedebugf("SendQueries: Put %##s (%s) at %d - %d",
3879 ka->resrec.name->c, DNSTypeName(ka->resrec.rrtype), queryptr - m->omsg.data, newptr - m->omsg.data);
3880 queryptr = newptr;
3881 KnownAnswerList = ka->NextInKAList;
3882 ka->NextInKAList = mDNSNULL;
3883 }
3884 else
3885 {
3886 // If we ran out of space and we have more than one question in the packet, that's an error --
3887 // we shouldn't have put more than one question if there was a risk of us running out of space.
3888 if (m->omsg.h.numQuestions > 1)
3889 LogMsg("SendQueries: Put %d answers; No more space for known answers", m->omsg.h.numAnswers);
3890 m->omsg.h.flags.b[0] |= kDNSFlag0_TC;
3891 break;
3892 }
3893 }
3894
3895 for (ar = m->ResourceRecords; ar; ar=ar->next)
3896 {
3897 if (ar->IncludeInProbe)
3898 {
3899 mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, &ar->resrec);
3900 ar->IncludeInProbe = mDNSfalse;
3901 if (newptr) queryptr = newptr;
3902 else LogMsg("SendQueries: How did we fail to have space for the Update record %s", ARDisplayString(m,ar));
3903 }
3904 }
3905
3906 for (q = m->Questions; q; q = q->next)
3907 {
3908 if (q->AnonInfo && q->AnonInfo->SendNow == intf->InterfaceID)
3909 {
3910 mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, q->AnonInfo->nsec3RR);
3911 if (newptr)
3912 {
3913 debugf("SendQueries: Added NSEC3 record %s on InterfaceID %p", RRDisplayString(m, q->AnonInfo->nsec3RR), intf->InterfaceID);
3914 queryptr = newptr;
3915 }
3916 else
3917 {
3918 LogMsg("SendQueries: ERROR!! Cannot add NSEC3 record %s on InterfaceID %p", RRDisplayString(m, q->AnonInfo->nsec3RR), intf->InterfaceID);
3919 }
3920 q->AnonInfo->SendNow = mDNSNULL;
3921 }
3922 }
3923
3924 if (queryptr > m->omsg.data)
3925 {
3926 // If we have data to send, add OWNER/TRACER/OWNER+TRACER option if necessary, then send packet
3927 if (OwnerRecordSpace || TraceRecordSpace)
3928 {
3929 AuthRecord opt;
3930 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
3931 opt.resrec.rrclass = NormalMaxDNSMessageData;
3932 opt.resrec.rdlength = sizeof(rdataOPT);
3933 opt.resrec.rdestimate = sizeof(rdataOPT);
3934 if (OwnerRecordSpace && TraceRecordSpace)
3935 {
3936 opt.resrec.rdlength += sizeof(rdataOPT); // Two options in this OPT record
3937 opt.resrec.rdestimate += sizeof(rdataOPT);
3938 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]);
3939 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[1]);
3940 }
3941 else if (OwnerRecordSpace)
3942 {
3943 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]);
3944 }
3945 else if (TraceRecordSpace)
3946 {
3947 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[0]);
3948 }
3949 queryptr = PutResourceRecordTTLWithLimit(&m->omsg, queryptr, &m->omsg.h.numAdditionals,
3950 &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData);
3951 if (!queryptr)
3952 {
3953 LogMsg("SendQueries: How did we fail to have space for %s %s OPT record (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", TraceRecordSpace ? "TRACER" : "",
3954 m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt));
3955 }
3956 if (queryptr > m->omsg.data + NormalMaxDNSMessageData)
3957 {
3958 if (m->omsg.h.numQuestions != 1 || m->omsg.h.numAnswers != 0 || m->omsg.h.numAuthorities != 1 || m->omsg.h.numAdditionals != 1)
3959 LogMsg("SendQueries: Why did we generate oversized packet with %s %s OPT record %p %p %p (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "",
3960 TraceRecordSpace ? "TRACER" : "", m->omsg.data, m->omsg.data + NormalMaxDNSMessageData, queryptr, m->omsg.h.numQuestions, m->omsg.h.numAnswers,
3961 m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt));
3962 }
3963 }
3964
3965 if ((m->omsg.h.flags.b[0] & kDNSFlag0_TC) && m->omsg.h.numQuestions > 1)
3966 LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet", m->omsg.h.numQuestions);
3967 debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p",
3968 m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s",
3969 m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s",
3970 m->omsg.h.numAuthorities, m->omsg.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID);
3971 if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL, useBackgroundTrafficClass);
3972 if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL, useBackgroundTrafficClass);
3973 if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10);
3974 if (++pktcount >= 1000)
3975 { LogMsg("SendQueries exceeded loop limit %d: giving up", pktcount); break; }
3976 // There might be more records left in the known answer list, or more questions to send
3977 // on this interface, so go around one more time and try again.
3978 }
3979 else // Nothing more to send on this interface; go to next
3980 {
3981 const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
3982 #if MDNS_DEBUGMSGS && 0
3983 const char *const msg = next ? "SendQueries: Nothing more on %p; moving to %p" : "SendQueries: Nothing more on %p";
3984 debugf(msg, intf, next);
3985 #endif
3986 intf = next;
3987 }
3988 }
3989
3990 // 4. Final housekeeping
3991
3992 // 4a. Debugging check: Make sure we announced all our records
3993 for (ar = m->ResourceRecords; ar; ar=ar->next)
3994 if (ar->SendRNow)
3995 {
3996 if (ar->ARType != AuthRecordLocalOnly && ar->ARType != AuthRecordP2P)
3997 LogInfo("SendQueries: No active interface %d to send probe: %d %s",
3998 IID(ar->SendRNow), IID(ar->resrec.InterfaceID), ARDisplayString(m, ar));
3999 ar->SendRNow = mDNSNULL;
4000 }
4001
4002 // 4b. When we have lingering cache records that we're keeping around for a few seconds in the hope
4003 // that their interface which went away might come back again, the logic will want to send queries
4004 // for those records, but we can't because their interface isn't here any more, so to keep the
4005 // state machine ticking over we just pretend we did so.
4006 // If the interface does not come back in time, the cache record will expire naturally
4007 FORALL_CACHERECORDS(slot, cg, cr)
4008 {
4009 if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries)
4010 {
4011 if (m->timenow + TicksTTL(cr)/50 - cr->NextRequiredQuery >= 0)
4012 {
4013 cr->UnansweredQueries++;
4014 cr->CRActiveQuestion->SendQNow = mDNSNULL;
4015 SetNextCacheCheckTimeForRecord(m, cr);
4016 }
4017 }
4018 }
4019
4020 // 4c. Debugging check: Make sure we sent all our planned questions
4021 // Do this AFTER the lingering cache records check above, because that will prevent spurious warnings for questions
4022 // we legitimately couldn't send because the interface is no longer available
4023 for (q = m->Questions; q; q=q->next)
4024 {
4025 if (q->SendQNow)
4026 {
4027 DNSQuestion *x;
4028 for (x = m->NewQuestions; x; x=x->next) if (x == q) break; // Check if this question is a NewQuestion
4029 // There will not be an active interface for questions applied to mDNSInterface_BLE
4030 // so don't log the warning in that case.
4031 if (q->InterfaceID != mDNSInterface_BLE)
4032 LogInfo("SendQueries: No active interface %d to send %s question: %d %##s (%s)",
4033 IID(q->SendQNow), x ? "new" : "old", IID(q->InterfaceID), q->qname.c, DNSTypeName(q->qtype));
4034 q->SendQNow = mDNSNULL;
4035 }
4036 q->CachedAnswerNeedsUpdate = mDNSfalse;
4037 }
4038}
4039
4040mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password, mDNSBool unicastOnly)
4041{
4042 int i, j;
4043
4044 mDNSu8 *ptr = m->omsg.data;
4045 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID);
4046 if (!intf) { LogMsg("SendARP: No interface with InterfaceID %p found", InterfaceID); return; }
4047
4048 // 0x00 Destination address
4049 for (i=0; i<6; i++) *ptr++ = EthAddr->b[i];
4050
4051 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us)
4052 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[0];
4053
4054 // 0x0C Ethertype (0x0842)
4055 *ptr++ = 0x08;
4056 *ptr++ = 0x42;
4057
4058 // 0x0E Wakeup sync sequence
4059 for (i=0; i<6; i++) *ptr++ = 0xFF;
4060
4061 // 0x14 Wakeup data
4062 for (j=0; j<16; j++) for (i=0; i<6; i++) *ptr++ = EthAddr->b[i];
4063
4064 // 0x74 Password
4065 for (i=0; i<6; i++) *ptr++ = password->b[i];
4066
4067 mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID);
4068
4069 if (!unicastOnly)
4070 {
4071 // For Ethernet switches that don't flood-foward packets with unknown unicast destination MAC addresses,
4072 // broadcast is the only reliable way to get a wakeup packet to the intended target machine.
4073 // For 802.11 WPA networks, where a sleeping target machine may have missed a broadcast/multicast
4074 // key rotation, unicast is the only way to get a wakeup packet to the intended target machine.
4075 // So, we send one of each, unicast first, then broadcast second.
4076 for (i=0; i<6; i++) m->omsg.data[i] = 0xFF;
4077 mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID);
4078 }
4079}
4080
4081// ***************************************************************************
4082#if COMPILER_LIKES_PRAGMA_MARK
4083#pragma mark -
4084#pragma mark - RR List Management & Task Management
4085#endif
4086
4087// Whenever a question is answered, reset its state so that we don't query
4088// the network repeatedly. This happens first time when we answer the question and
4089// and later when we refresh the cache.
4090mDNSlocal void ResetQuestionState(mDNS *const m, DNSQuestion *q)
4091{
4092 q->LastQTime = m->timenow;
4093 q->LastQTxTime = m->timenow;
4094 q->RecentAnswerPkts = 0;
4095 q->ThisQInterval = MaxQuestionInterval;
4096 q->RequestUnicast = 0;
4097 // Reset unansweredQueries so that we don't penalize this server later when we
4098 // start sending queries when the cache expires.
4099 q->unansweredQueries = 0;
4100 debugf("ResetQuestionState: Set MaxQuestionInterval for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
4101}
4102
4103// Note: AnswerCurrentQuestionWithResourceRecord can call a user callback, which may change the record list and/or question list.
4104// Any code walking either list must use the m->CurrentQuestion (and possibly m->CurrentRecord) mechanism to protect against this.
4105// In fact, to enforce this, the routine will *only* answer the question currently pointed to by m->CurrentQuestion,
4106// which will be auto-advanced (possibly to NULL) if the client callback cancels the question.
4107mDNSexport void AnswerCurrentQuestionWithResourceRecord(mDNS *const m, CacheRecord *const rr, const QC_result AddRecord)
4108{
4109 DNSQuestion *const q = m->CurrentQuestion;
4110 const mDNSBool followcname = FollowCNAME(q, &rr->resrec, AddRecord);
4111
4112 verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s",
4113 q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, CRDisplayString(m, rr));
4114
4115 // When the response for the question was validated, the entire rrset was validated. If we deliver
4116 // a RMV for a single record in the rrset, we invalidate the response. If we deliver another add
4117 // in the future, we will do the revalidation again.
4118 //
4119 // Also, if we deliver an ADD for a negative cache record and it has no NSEC/NSEC3, the ValidationStatus needs
4120 // to be reset. This happens normally when we deliver a "secure" negative response followed by an insecure
4121 // negative response which can happen e.g., when disconnecting from network that leads to a negative response
4122 // due to no DNS servers. As we don't deliver RMVs for negative responses that were delivered before, we need
4123 // to do it on the next ADD of a negative cache record. This ADD could be the result of a timeout, no DNS servers
4124 // etc. in which case we need to reset the state to make sure we don't deliver them as secure. If this is
4125 // a real negative response, we would reset the state here and validate the results at the end of this function.
4126 // or the real response again if we purge the cache.
4127 if (q->ValidationRequired && ((AddRecord == QC_rmv) ||
4128 (rr->resrec.RecordType == kDNSRecordTypePacketNegative && (AddRecord == QC_add))))
4129 {
4130 q->ValidationStatus = 0;
4131 q->ValidationState = DNSSECValRequired;
4132 }
4133
4134 // Normally we don't send out the unicast query if we have answered using our local only auth records e.g., /etc/hosts.
4135 // But if the query for "A" record has a local answer but query for "AAAA" record has no local answer, we might
4136 // send the AAAA query out which will come back with CNAME and will also answer the "A" query. To prevent that,
4137 // we check to see if that query already has a unique local answer.
4138 if (q->LOAddressAnswers)
4139 {
4140 LogInfo("AnswerCurrentQuestionWithResourceRecord: Question %p %##s (%s) not answering with record %s due to "
4141 "LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr),
4142 q->LOAddressAnswers);
4143 return;
4144 }
4145
4146 if (QuerySuppressed(q))
4147 {
4148 // If the query is suppressed, then we don't want to answer from the cache. But if this query is
4149 // supposed to time out, we still want to callback the clients. We do this only for TimeoutQuestions
4150 // that are timing out, which we know are answered with negative cache record when timing out.
4151 if (!q->TimeoutQuestion || rr->resrec.RecordType != kDNSRecordTypePacketNegative || (m->timenow - q->StopTime < 0))
4152 return;
4153 }
4154
4155#if AWD_METRICS
4156 if ((AddRecord == QC_add) && Question_uDNS(q) && !followcname)
4157 {
4158 const domainname * queryName;
4159 mDNSu32 responseLatencyMs;
4160 mDNSBool isForCellular;
4161
4162 queryName = q->metrics.originalQName ? q->metrics.originalQName : &q->qname;
4163 isForCellular = (q->qDNSServer && q->qDNSServer->cellIntf);
4164 if (!q->metrics.answered)
4165 {
4166 if (q->metrics.querySendCount > 0)
4167 {
4168 responseLatencyMs = ((m->timenow - q->metrics.firstQueryTime) * 1000) / mDNSPlatformOneSecond;
4169 }
4170 else
4171 {
4172 responseLatencyMs = 0;
4173 }
4174
4175 MetricsUpdateDNSQueryStats(queryName, q->qtype, &rr->resrec, q->metrics.querySendCount, responseLatencyMs, isForCellular);
4176 q->metrics.answered = mDNStrue;
4177 }
4178 if (q->metrics.querySendCount > 0)
4179 {
4180 MetricsUpdateDNSResolveStats(queryName, &rr->resrec, isForCellular);
4181 }
4182 }
4183#endif
4184 // Note: Use caution here. In the case of records with rr->DelayDelivery set, AnswerCurrentQuestionWithResourceRecord(... mDNStrue)
4185 // may be called twice, once when the record is received, and again when it's time to notify local clients.
4186 // If any counters or similar are added here, care must be taken to ensure that they are not double-incremented by this.
4187
4188 rr->LastUsed = m->timenow;
4189 if (AddRecord == QC_add && !q->DuplicateOf && rr->CRActiveQuestion != q)
4190 {
4191 if (!rr->CRActiveQuestion) m->rrcache_active++; // If not previously active, increment rrcache_active count
4192 debugf("AnswerCurrentQuestionWithResourceRecord: Updating CRActiveQuestion from %p to %p for cache record %s, CurrentAnswer %d",
4193 rr->CRActiveQuestion, q, CRDisplayString(m,rr), q->CurrentAnswers);
4194 rr->CRActiveQuestion = q; // We know q is non-null
4195 SetNextCacheCheckTimeForRecord(m, rr);
4196 }
4197
4198 // If this is:
4199 // (a) a no-cache add, where we've already done at least one 'QM' query, or
4200 // (b) a normal add, where we have at least one unique-type answer,
4201 // then there's no need to keep polling the network.
4202 // (If we have an answer in the cache, then we'll automatically ask again in time to stop it expiring.)
4203 // We do this for mDNS questions and uDNS one-shot questions, but not for
4204 // uDNS LongLived questions, because that would mess up our LLQ lease renewal timing.
4205 if ((AddRecord == QC_addnocache && !q->RequestUnicast) ||
4206 (AddRecord == QC_add && (q->ExpectUnique || (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))))
4207 if (ActiveQuestion(q) && (mDNSOpaque16IsZero(q->TargetQID) || !q->LongLived))
4208 {
4209 ResetQuestionState(m, q);
4210 }
4211
4212 if (rr->DelayDelivery) return; // We'll come back later when CacheRecordDeferredAdd() calls us
4213
4214#if USE_DNS64
4215 // If DNS64StateMachine() returns true, then the question was restarted as a different question, so return.
4216 if (!mDNSOpaque16IsZero(q->TargetQID) && DNS64StateMachine(m, q, &rr->resrec, AddRecord)) return;
4217#endif
4218
4219#ifdef USE_LIBIDN
4220 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) // If negative answer, check if we need to try Punycode conversion
4221 {
4222 domainname newname;
4223 if (PerformNextPunycodeConversion(q, &newname)) // Itertative Punycode conversion succeeded, so reissue question with new name
4224 {
4225 UDPSocket *const sock = q->LocalSocket; // Save old socket and transaction ID
4226 const mDNSOpaque16 id = q->TargetQID;
4227 q->LocalSocket = mDNSNULL;
4228 mDNS_StopQuery_internal(m, q); // Stop old query
4229 AssignDomainName(&q->qname, &newname); // Update qname
4230 q->qnamehash = DomainNameHashValue(&q->qname); // and namehash
4231 mDNS_StartQuery_internal(m, q); // Start new query
4232
4233 if (sock) // Transplant saved socket, if appropriate
4234 {
4235 if (q->DuplicateOf) mDNSPlatformUDPClose(sock);
4236 else { q->LocalSocket = sock; q->TargetQID = id; }
4237 }
4238 return; // All done for now; wait until we get the next answer
4239 }
4240 }
4241#endif // USE_LIBIDN
4242
4243 // Only deliver negative answers if client has explicitly requested them except when we are forcing a negative response
4244 // for the purpose of retrying search domains/timeout OR the question is suppressed
4245 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative || (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype)))
4246 if (!AddRecord || (AddRecord != QC_suppressed && AddRecord != QC_forceresponse && !q->ReturnIntermed)) return;
4247
4248 // For CNAME results to non-CNAME questions, only inform the client if they explicitly requested that
4249 if (q->QuestionCallback && !q->NoAnswer && (!followcname || q->ReturnIntermed))
4250 {
4251 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls
4252 if (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype))
4253 {
4254 CacheRecord neg;
4255 MakeNegativeCacheRecord(m, &neg, &q->qname, q->qnamehash, q->qtype, q->qclass, 1, rr->resrec.InterfaceID, q->qDNSServer);
4256 q->QuestionCallback(m, q, &neg.resrec, AddRecord);
4257 }
4258 else
4259 {
4260#if USE_DNS64
4261 if (DNS64ShouldAnswerQuestion(q, &rr->resrec))
4262 {
4263 DNS64AnswerQuestion(m, q, &rr->resrec, AddRecord);
4264 }
4265 else
4266#endif
4267 {
4268 q->QuestionCallback(m, q, &rr->resrec, AddRecord);
4269 }
4270 }
4271 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
4272 }
4273 // If this is an "Add" operation and this question needs validation, validate the response.
4274 // In the case of negative responses, extra care should be taken. Negative cache records are
4275 // used for many purposes. For example,
4276 //
4277 // 1) Suppressing questions (SuppressUnusable)
4278 // 2) Timeout questions
4279 // 3) The name does not exist
4280 // 4) No DNS servers are available and we need a quick response for the application
4281 //
4282 // (1) and (2) are handled by "QC_add" check as AddRecord would be "QC_forceresponse" or "QC_suppressed"
4283 // in that case. For (3), it is possible that we don't get nsecs back but we still need to call
4284 // VerifySignature so that we can deliver the appropriate DNSSEC result. There is no point in verifying
4285 // signature for (4) and hence the explicit check for q->qDNSServer.
4286 //
4287 if (m->CurrentQuestion == q && (AddRecord == QC_add) && !q->ValidatingResponse && q->ValidationRequired &&
4288 q->ValidationState == DNSSECValRequired && q->qDNSServer)
4289 {
4290 q->ValidationState = DNSSECValInProgress;
4291 // Treat it as callback call as that's what dnssec code expects
4292 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls
4293 VerifySignature(m, mDNSNULL, q);
4294 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
4295 return;
4296 }
4297
4298 // Note: Proceed with caution here because client callback function is allowed to do anything,
4299 // including starting/stopping queries, registering/deregistering records, etc.
4300 //
4301 // If we get a CNAME back while we are validating the response (i.e., CNAME for DS, DNSKEY, RRSIG),
4302 // don't follow them. If it is a ValidationRequired question, wait for the CNAME to be validated
4303 // first before following it
4304 if ((m->CurrentQuestion == q) && followcname && !ValidatingQuestion(q))
4305 AnswerQuestionByFollowingCNAME(m, q, &rr->resrec);
4306}
4307
4308mDNSlocal void CacheRecordDeferredAdd(mDNS *const m, CacheRecord *rr)
4309{
4310 rr->DelayDelivery = 0;
4311 if (m->CurrentQuestion)
4312 LogMsg("CacheRecordDeferredAdd ERROR m->CurrentQuestion already set: %##s (%s)",
4313 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
4314 m->CurrentQuestion = m->Questions;
4315 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
4316 {
4317 DNSQuestion *q = m->CurrentQuestion;
4318 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
4319 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
4320 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
4321 m->CurrentQuestion = q->next;
4322 }
4323 m->CurrentQuestion = mDNSNULL;
4324}
4325
4326mDNSlocal mDNSs32 CheckForSoonToExpireRecords(mDNS *const m, const domainname *const name, const mDNSu32 namehash, mDNSBool *purge)
4327{
4328 const mDNSs32 threshhold = m->timenow + mDNSPlatformOneSecond; // See if there are any records expiring within one second
4329 const mDNSs32 start = m->timenow - 0x10000000;
4330 mDNSs32 delay = start;
4331 CacheGroup *cg = CacheGroupForName(m, namehash, name);
4332 const CacheRecord *rr;
4333
4334 if (purge)
4335 *purge = mDNSfalse;
4336 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
4337 {
4338 // If there are records that will expire soon, there are cases that need delayed
4339 // delivery of events:
4340 //
4341 // 1) A new cache entry is about to be added as a replacement. The caller needs to
4342 // deliver a RMV (for the current old entry) followed by ADD (for the new entry).
4343 // It needs to schedule the timer for the next cache expiry (ScheduleNextCacheCheckTime),
4344 // so that the cache entry can be purged (purging causes the RMV followed by ADD)
4345 //
4346 // 2) A new question is about to be answered and the caller needs to know whether it's
4347 // scheduling should be delayed so that the question is not answered with this record.
4348 // Instead of delivering an ADD (old entry) followed by RMV (old entry) and another ADD
4349 // (new entry), a single ADD can be delivered by delaying the scheduling of the question
4350 // immediately.
4351 //
4352 // When the unicast cache record is created, it's TTL has been extended beyond its value
4353 // given in the resource record (See RRAdjustTTL). If it is in the "extended" time, the
4354 // cache is already expired and we set "purge" to indicate that. When "purge" is set, the
4355 // return value of the function should be ignored by the callers.
4356 //
4357 // Note: For case (1), "purge" argument is NULL and hence the following checks are skipped.
4358 // It is okay to skip in that case because the cache records have been set to expire almost
4359 // immediately and the extended time does not apply.
4360 //
4361 // Also, if there is already an active question we don't try to optimize as purging the cache
4362 // would end up delivering RMV for the active question and hence we avoid that.
4363
4364 if (purge && !rr->resrec.InterfaceID && !rr->CRActiveQuestion && rr->resrec.rroriginalttl)
4365 {
4366 mDNSu32 uTTL = RRUnadjustedTTL(rr->resrec.rroriginalttl);
4367 if (m->timenow - (rr->TimeRcvd + ((mDNSs32)uTTL * mDNSPlatformOneSecond)) >= 0)
4368 {
4369 LogInfo("CheckForSoonToExpireRecords: %s: rroriginalttl %u, unadjustedTTL %u, currentTTL %u",
4370 CRDisplayString(m, rr), rr->resrec.rroriginalttl, uTTL, (m->timenow - rr->TimeRcvd)/mDNSPlatformOneSecond);
4371 *purge = mDNStrue;
4372 continue;
4373 }
4374 }
4375 if (threshhold - RRExpireTime(rr) >= 0) // If we have records about to expire within a second
4376 {
4377 if (delay - RRExpireTime(rr) < 0) // then delay until after they've been deleted
4378 delay = RRExpireTime(rr);
4379 }
4380 }
4381 if (delay - start > 0)
4382 return(NonZeroTime(delay));
4383 else
4384 return(0);
4385}
4386
4387// CacheRecordAdd is only called from CreateNewCacheEntry, *never* directly as a result of a client API call.
4388// If new questions are created as a result of invoking client callbacks, they will be added to
4389// the end of the question list, and m->NewQuestions will be set to indicate the first new question.
4390// rr is a new CacheRecord just received into our cache
4391// (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique).
4392// Note: CacheRecordAdd calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
4393// which may change the record list and/or question list.
4394// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
4395mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr)
4396{
4397 DNSQuestion *q;
4398
4399 // We stop when we get to NewQuestions -- if we increment their CurrentAnswers/LargeAnswers/UniqueAnswers
4400 // counters here we'll end up double-incrementing them when we do it again in AnswerNewQuestion().
4401 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
4402 {
4403 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
4404 {
4405 // If this question is one that's actively sending queries, and it's received ten answers within one
4406 // second of sending the last query packet, then that indicates some radical network topology change,
4407 // so reset its exponential backoff back to the start. We must be at least at the eight-second interval
4408 // to do this. If we're at the four-second interval, or less, there's not much benefit accelerating
4409 // because we will anyway send another query within a few seconds. The first reset query is sent out
4410 // randomized over the next four seconds to reduce possible synchronization between machines.
4411 if (q->LastAnswerPktNum != m->PktNum)
4412 {
4413 q->LastAnswerPktNum = m->PktNum;
4414 if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q) && ++q->RecentAnswerPkts >= 10 &&
4415 q->ThisQInterval > InitialQuestionInterval * QuestionIntervalStep3 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond)
4416 {
4417 LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst (%d); restarting exponential backoff sequence (%d)",
4418 q->qname.c, DNSTypeName(q->qtype), q->RecentAnswerPkts, q->ThisQInterval);
4419 q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4);
4420 q->ThisQInterval = InitialQuestionInterval;
4421 SetNextQueryTime(m,q);
4422 }
4423 }
4424 verbosedebugf("CacheRecordAdd %p %##s (%s) %lu %#a:%d question %p", rr, rr->resrec.name->c,
4425 DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl, rr->resrec.rDNSServer ?
4426 &rr->resrec.rDNSServer->addr : mDNSNULL, mDNSVal16(rr->resrec.rDNSServer ?
4427 rr->resrec.rDNSServer->port : zeroIPPort), q);
4428 q->CurrentAnswers++;
4429
4430 q->unansweredQueries = 0;
4431 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
4432 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
4433 if (q->CurrentAnswers > 4000)
4434 {
4435 static int msgcount = 0;
4436 if (msgcount++ < 10)
4437 LogMsg("CacheRecordAdd: %##s (%s) has %d answers; shedding records to resist DOS attack",
4438 q->qname.c, DNSTypeName(q->qtype), q->CurrentAnswers);
4439 rr->resrec.rroriginalttl = 0;
4440 rr->UnansweredQueries = MaxUnansweredQueries;
4441 }
4442 }
4443 }
4444
4445 if (!rr->DelayDelivery)
4446 {
4447 if (m->CurrentQuestion)
4448 LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
4449 m->CurrentQuestion = m->Questions;
4450 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
4451 {
4452 q = m->CurrentQuestion;
4453 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
4454 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
4455 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
4456 m->CurrentQuestion = q->next;
4457 }
4458 m->CurrentQuestion = mDNSNULL;
4459 }
4460
4461 SetNextCacheCheckTimeForRecord(m, rr);
4462}
4463
4464// NoCacheAnswer is only called from mDNSCoreReceiveResponse, *never* directly as a result of a client API call.
4465// If new questions are created as a result of invoking client callbacks, they will be added to
4466// the end of the question list, and m->NewQuestions will be set to indicate the first new question.
4467// rr is a new CacheRecord just received from the wire (kDNSRecordTypePacketAns/AnsUnique/Add/AddUnique)
4468// but we don't have any place to cache it. We'll deliver question 'add' events now, but we won't have any
4469// way to deliver 'remove' events in future, nor will we be able to include this in known-answer lists,
4470// so we immediately bump ThisQInterval up to MaxQuestionInterval to avoid pounding the network.
4471// Note: NoCacheAnswer calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
4472// which may change the record list and/or question list.
4473// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
4474mDNSlocal void NoCacheAnswer(mDNS *const m, CacheRecord *rr)
4475{
4476 LogMsg("No cache space: Delivering non-cached result for %##s", m->rec.r.resrec.name->c);
4477 if (m->CurrentQuestion)
4478 LogMsg("NoCacheAnswer ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
4479 m->CurrentQuestion = m->Questions;
4480 // We do this for *all* questions, not stopping when we get to m->NewQuestions,
4481 // since we're not caching the record and we'll get no opportunity to do this later
4482 while (m->CurrentQuestion)
4483 {
4484 DNSQuestion *q = m->CurrentQuestion;
4485 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
4486 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_addnocache); // QC_addnocache means "don't expect remove events for this"
4487 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
4488 m->CurrentQuestion = q->next;
4489 }
4490 m->CurrentQuestion = mDNSNULL;
4491}
4492
4493// CacheRecordRmv is only called from CheckCacheExpiration, which is called from mDNS_Execute.
4494// Note that CacheRecordRmv is *only* called for records that are referenced by at least one active question.
4495// If new questions are created as a result of invoking client callbacks, they will be added to
4496// the end of the question list, and m->NewQuestions will be set to indicate the first new question.
4497// rr is an existing cache CacheRecord that just expired and is being deleted
4498// (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique).
4499// Note: CacheRecordRmv calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
4500// which may change the record list and/or question list.
4501// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
4502mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr)
4503{
4504 if (m->CurrentQuestion)
4505 LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set: %##s (%s)",
4506 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
4507 m->CurrentQuestion = m->Questions;
4508
4509 // We stop when we get to NewQuestions -- for new questions their CurrentAnswers/LargeAnswers/UniqueAnswers counters
4510 // will all still be zero because we haven't yet gone through the cache counting how many answers we have for them.
4511 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
4512 {
4513 DNSQuestion *q = m->CurrentQuestion;
4514 // When a question enters suppressed state, we generate RMV events and generate a negative
4515 // response. A cache may be present that answers this question e.g., cache entry generated
4516 // before the question became suppressed. We need to skip the suppressed questions here as
4517 // the RMV event has already been generated.
4518 if (!QuerySuppressed(q) && ResourceRecordAnswersQuestion(&rr->resrec, q))
4519 {
4520 verbosedebugf("CacheRecordRmv %p %s", rr, CRDisplayString(m, rr));
4521 q->FlappingInterface1 = mDNSNULL;
4522 q->FlappingInterface2 = mDNSNULL;
4523
4524 if (q->CurrentAnswers == 0)
4525 LogMsg("CacheRecordRmv ERROR!!: How can CurrentAnswers already be zero for %p %##s (%s) DNSServer %#a:%d",
4526 q, q->qname.c, DNSTypeName(q->qtype), q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL,
4527 mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort));
4528 else
4529 {
4530 q->CurrentAnswers--;
4531 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--;
4532 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--;
4533 }
4534
4535 // If we have dropped below the answer threshold for this mDNS question,
4536 // restart the queries at InitialQuestionInterval.
4537 if (mDNSOpaque16IsZero(q->TargetQID) && (q->BrowseThreshold > 0) && (q->CurrentAnswers < q->BrowseThreshold))
4538 {
4539 q->ThisQInterval = InitialQuestionInterval;
4540 q->LastQTime = m->timenow - q->ThisQInterval;
4541 SetNextQueryTime(m,q);
4542 LogInfo("CacheRecordRmv: (%s) %##s dropped below threshold of %d answers",
4543 DNSTypeName(q->qtype), q->qname.c, q->BrowseThreshold);
4544 }
4545 if (rr->resrec.rdata->MaxRDLength) // Never generate "remove" events for negative results
4546 {
4547 if (q->CurrentAnswers == 0)
4548 {
4549 LogInfo("CacheRecordRmv: Last answer for %##s (%s) expired from cache; will reconfirm antecedents",
4550 q->qname.c, DNSTypeName(q->qtype));
4551 ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0);
4552 }
4553 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv);
4554 }
4555 }
4556 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
4557 m->CurrentQuestion = q->next;
4558 }
4559 m->CurrentQuestion = mDNSNULL;
4560}
4561
4562mDNSlocal void ReleaseCacheEntity(mDNS *const m, CacheEntity *e)
4563{
4564#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1
4565 unsigned int i;
4566 for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF;
4567#endif
4568 e->next = m->rrcache_free;
4569 m->rrcache_free = e;
4570 m->rrcache_totalused--;
4571}
4572
4573mDNSlocal void ReleaseCacheGroup(mDNS *const m, CacheGroup **cp)
4574{
4575 CacheEntity *e = (CacheEntity *)(*cp);
4576 //LogMsg("ReleaseCacheGroup: Releasing CacheGroup for %p, %##s", (*cp)->name->c, (*cp)->name->c);
4577 if ((*cp)->rrcache_tail != &(*cp)->members)
4578 LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrcache_tail != &(*cp)->members)");
4579 //if ((*cp)->name != (domainname*)((*cp)->namestorage))
4580 // LogMsg("ReleaseCacheGroup: %##s, %p %p", (*cp)->name->c, (*cp)->name, (domainname*)((*cp)->namestorage));
4581 if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name);
4582 (*cp)->name = mDNSNULL;
4583 *cp = (*cp)->next; // Cut record from list
4584 ReleaseCacheEntity(m, e);
4585}
4586
4587mDNSlocal void ReleaseAdditionalCacheRecords(mDNS *const m, CacheRecord **rp)
4588{
4589 while (*rp)
4590 {
4591 CacheRecord *rr = *rp;
4592 *rp = (*rp)->next; // Cut record from list
4593 if (rr->resrec.rdata && rr->resrec.rdata != (RData*)&rr->smallrdatastorage)
4594 {
4595 mDNSPlatformMemFree(rr->resrec.rdata);
4596 rr->resrec.rdata = mDNSNULL;
4597 }
4598 // NSEC or SOA records that are not added to the CacheGroup do not share the name
4599 // of the CacheGroup.
4600 if (rr->resrec.name)
4601 {
4602 debugf("ReleaseAdditionalCacheRecords: freeing cached record %##s (%s)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
4603 mDNSPlatformMemFree((void *)rr->resrec.name);
4604 rr->resrec.name = mDNSNULL;
4605 }
4606 // Don't count the NSEC3 records used by anonymous browse/reg
4607 if (!rr->resrec.InterfaceID)
4608 {
4609 m->rrcache_totalused_unicast -= rr->resrec.rdlength;
4610 if (DNSSECRecordType(rr->resrec.rrtype))
4611 BumpDNSSECStats(m, kStatsActionDecrement, kStatsTypeMemoryUsage, rr->resrec.rdlength);
4612 }
4613 ReleaseCacheEntity(m, (CacheEntity *)rr);
4614 }
4615}
4616
4617mDNSexport void ReleaseCacheRecord(mDNS *const m, CacheRecord *r)
4618{
4619 CacheGroup *cg;
4620
4621 //LogMsg("ReleaseCacheRecord: Releasing %s", CRDisplayString(m, r));
4622 if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->smallrdatastorage) mDNSPlatformMemFree(r->resrec.rdata);
4623 r->resrec.rdata = mDNSNULL;
4624
4625 cg = CacheGroupForRecord(m, &r->resrec);
4626
4627 if (!cg)
4628 {
4629 // It is okay to have this printed for NSEC/NSEC3s
4630 LogInfo("ReleaseCacheRecord: ERROR!! cg NULL for %##s (%s)", r->resrec.name->c, DNSTypeName(r->resrec.rrtype));
4631 }
4632 // When NSEC records are not added to the cache, it is usually cached at the "nsec" list
4633 // of the CacheRecord. But sometimes they may be freed without adding to the "nsec" list
4634 // (which is handled below) and in that case it should be freed here.
4635 if (r->resrec.name && cg && r->resrec.name != cg->name)
4636 {
4637 debugf("ReleaseCacheRecord: freeing %##s (%s)", r->resrec.name->c, DNSTypeName(r->resrec.rrtype));
4638 mDNSPlatformMemFree((void *)r->resrec.name);
4639 }
4640 r->resrec.name = mDNSNULL;
4641
4642 if (r->resrec.AnonInfo)
4643 {
4644 debugf("ReleaseCacheRecord: freeing AnonInfo for %##s (%s)", r->resrec.name->c, DNSTypeName(r->resrec.rrtype));
4645 FreeAnonInfo((void *)r->resrec.AnonInfo);
4646 }
4647 r->resrec.AnonInfo = mDNSNULL;
4648
4649 if (!r->resrec.InterfaceID)
4650 {
4651 m->rrcache_totalused_unicast -= r->resrec.rdlength;
4652 if (DNSSECRecordType(r->resrec.rrtype))
4653 BumpDNSSECStats(m, kStatsActionDecrement, kStatsTypeMemoryUsage, r->resrec.rdlength);
4654 }
4655
4656 ReleaseAdditionalCacheRecords(m, &r->nsec);
4657 ReleaseAdditionalCacheRecords(m, &r->soa);
4658
4659 ReleaseCacheEntity(m, (CacheEntity *)r);
4660}
4661
4662// Note: We want to be careful that we deliver all the CacheRecordRmv calls before delivering
4663// CacheRecordDeferredAdd calls. The in-order nature of the cache lists ensures that all
4664// callbacks for old records are delivered before callbacks for newer records.
4665mDNSlocal void CheckCacheExpiration(mDNS *const m, const mDNSu32 slot, CacheGroup *const cg)
4666{
4667 CacheRecord **rp = &cg->members;
4668
4669 if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; }
4670 m->lock_rrcache = 1;
4671
4672 while (*rp)
4673 {
4674 CacheRecord *const rr = *rp;
4675 mDNSs32 event = RRExpireTime(rr);
4676 if (m->timenow - event >= 0) // If expired, delete it
4677 {
4678 *rp = rr->next; // Cut it from the list
4679
4680 verbosedebugf("CheckCacheExpiration: Deleting%7d %7d %p %s",
4681 m->timenow - rr->TimeRcvd, rr->resrec.rroriginalttl, rr->CRActiveQuestion, CRDisplayString(m, rr));
4682 if (rr->CRActiveQuestion) // If this record has one or more active questions, tell them it's going away
4683 {
4684 DNSQuestion *q = rr->CRActiveQuestion;
4685 // When a cache record is about to expire, we expect to do four queries at 80-82%, 85-87%, 90-92% and
4686 // then 95-97% of the TTL. If the DNS server does not respond, then we will remove the cache entry
4687 // before we pick a new DNS server. As the question interval is set to MaxQuestionInterval, we may
4688 // not send out a query anytime soon. Hence, we need to reset the question interval. If this is
4689 // a normal deferred ADD case, then AnswerCurrentQuestionWithResourceRecord will reset it to
4690 // MaxQuestionInterval. If we have inactive questions referring to negative cache entries,
4691 // don't ressurect them as they will deliver duplicate "No such Record" ADD events
4692 if (!mDNSOpaque16IsZero(q->TargetQID) && !q->LongLived && ActiveQuestion(q))
4693 {
4694 q->ThisQInterval = InitialQuestionInterval;
4695 q->LastQTime = m->timenow - q->ThisQInterval;
4696 SetNextQueryTime(m, q);
4697 }
4698 CacheRecordRmv(m, rr);
4699 m->rrcache_active--;
4700 }
4701 ReleaseCacheRecord(m, rr);
4702 }
4703 else // else, not expired; see if we need to query
4704 {
4705 // If waiting to delay delivery, do nothing until then
4706 if (rr->DelayDelivery && rr->DelayDelivery - m->timenow > 0)
4707 event = rr->DelayDelivery;
4708 else
4709 {
4710 if (rr->DelayDelivery) CacheRecordDeferredAdd(m, rr);
4711 if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
4712 {
4713 if (m->timenow - rr->NextRequiredQuery < 0) // If not yet time for next query
4714 event = NextCacheCheckEvent(rr); // then just record when we want the next query
4715 else // else trigger our question to go out now
4716 {
4717 // Set NextScheduledQuery to timenow so that SendQueries() will run.
4718 // SendQueries() will see that we have records close to expiration, and send FEQs for them.
4719 m->NextScheduledQuery = m->timenow;
4720 // After sending the query we'll increment UnansweredQueries and call SetNextCacheCheckTimeForRecord(),
4721 // which will correctly update m->NextCacheCheck for us.
4722 event = m->timenow + FutureTime;
4723 }
4724 }
4725 }
4726 verbosedebugf("CheckCacheExpiration:%6d %5d %s",
4727 (event - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m, rr));
4728 if (m->rrcache_nextcheck[slot] - event > 0)
4729 m->rrcache_nextcheck[slot] = event;
4730 rp = &rr->next;
4731 }
4732 }
4733 if (cg->rrcache_tail != rp) verbosedebugf("CheckCacheExpiration: Updating CacheGroup tail from %p to %p", cg->rrcache_tail, rp);
4734 cg->rrcache_tail = rp;
4735 m->lock_rrcache = 0;
4736}
4737
4738// "LORecord" includes both LocalOnly and P2P record. This function assumes m->CurrentQuestion is pointing to "q".
4739//
4740// If "CheckOnly" is set to "true", the question won't be answered but just check to see if there is an answer and
4741// returns true if there is an answer.
4742//
4743// If "CheckOnly" is set to "false", the question will be answered if there is a LocalOnly/P2P record and
4744// returns true to indicate the same.
4745mDNSlocal mDNSBool AnswerQuestionWithLORecord(mDNS *const m, DNSQuestion *q, mDNSBool checkOnly)
4746{
4747 AuthRecord *lr;
4748 AuthGroup *ag;
4749
4750 if (m->CurrentRecord)
4751 LogMsg("AnswerQuestionWithLORecord ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
4752
4753 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname);
4754 if (ag)
4755 {
4756 m->CurrentRecord = ag->members;
4757 while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords)
4758 {
4759 AuthRecord *rr = m->CurrentRecord;
4760 m->CurrentRecord = rr->next;
4761 //
4762 // If the question is mDNSInterface_LocalOnly, all records local to the machine should be used
4763 // to answer the query. This is handled in AnswerNewLocalOnlyQuestion.
4764 //
4765 // We handle mDNSInterface_Any and scoped questions here. See LocalOnlyRecordAnswersQuestion for more
4766 // details on how we handle this case. For P2P we just handle "Interface_Any" questions. For LocalOnly
4767 // we handle both mDNSInterface_Any and scoped questions.
4768
4769 if (rr->ARType == AuthRecordLocalOnly || (rr->ARType == AuthRecordP2P && (q->InterfaceID == mDNSInterface_Any || q->InterfaceID == mDNSInterface_BLE)))
4770 if (LocalOnlyRecordAnswersQuestion(rr, q))
4771 {
4772 if (checkOnly)
4773 {
4774 LogInfo("AnswerQuestionWithLORecord: question %##s (%s) answered by %s", q->qname.c, DNSTypeName(q->qtype),
4775 ARDisplayString(m, rr));
4776 m->CurrentRecord = mDNSNULL;
4777 return mDNStrue;
4778 }
4779 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue);
4780 if (m->CurrentQuestion != q)
4781 break; // If callback deleted q, then we're finished here
4782 }
4783 }
4784 }
4785 m->CurrentRecord = mDNSNULL;
4786
4787 if (m->CurrentQuestion != q)
4788 {
4789 LogInfo("AnswerQuestionWithLORecord: Question deleted while while answering LocalOnly record answers");
4790 return mDNStrue;
4791 }
4792
4793 if (q->LOAddressAnswers)
4794 {
4795 LogInfo("AnswerQuestionWithLORecord: Question %p %##s (%s) answered using local auth records LOAddressAnswers %d",
4796 q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers);
4797 return mDNStrue;
4798 }
4799
4800 // Before we go check the cache and ship this query on the wire, we have to be sure that there are
4801 // no local records that could possibly answer this question. As we did not check the NewLocalRecords, we
4802 // need to just peek at them to see whether it will answer this question. If it would answer, pretend
4803 // that we answered. AnswerAllLocalQuestionsWithLocalAuthRecord will answer shortly. This happens normally
4804 // when we add new /etc/hosts entries and restart the question. It is a new question and also a new record.
4805 if (ag)
4806 {
4807 lr = ag->NewLocalOnlyRecords;
4808 while (lr)
4809 {
4810 if (UniqueLocalOnlyRecord(lr) && LocalOnlyRecordAnswersQuestion(lr, q))
4811 {
4812 LogInfo("AnswerQuestionWithLORecord: Question %p %##s (%s) will be answered using new local auth records "
4813 " LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers);
4814 return mDNStrue;
4815 }
4816 lr = lr->next;
4817 }
4818 }
4819 return mDNSfalse;
4820}
4821
4822// Today, we suppress questions (not send them on the wire) for several reasons e.g.,
4823// AAAA query is suppressed because no IPv6 capability or PID is not allowed to make
4824// DNS requests. We need to temporarily suspend the suppress status so that we can
4825// deliver a negative response (AnswerCurrentQuestionWithResourceRecord does not answer
4826// suppressed questions) and reset it back. In the future, if there are other
4827// reasons for suppressing the query, this function should be updated.
4828mDNSlocal void AnswerSuppressedQuestion(mDNS *const m, DNSQuestion *q)
4829{
4830 mDNSBool SuppressQuery;
4831 mDNSBool DisallowPID;
4832
4833 // If the client did not set the kDNSServiceFlagsReturnIntermediates flag, then don't generate a negative response, just
4834 // deactivate the DNSQuestion.
4835 if (!q->ReturnIntermed)
4836 {
4837 q->ThisQInterval = 0;
4838 return;
4839 }
4840
4841 SuppressQuery = q->SuppressQuery;
4842 DisallowPID = q->DisallowPID;
4843
4844 // make sure that QuerySuppressed() returns false
4845 q->SuppressQuery = mDNSfalse;
4846 q->DisallowPID = mDNSfalse;
4847
4848 GenerateNegativeResponse(m, mDNSInterface_Any, QC_suppressed);
4849
4850 q->SuppressQuery = SuppressQuery;
4851 q->DisallowPID = DisallowPID;
4852}
4853
4854mDNSlocal void AnswerNewQuestion(mDNS *const m)
4855{
4856 mDNSBool ShouldQueryImmediately = mDNStrue;
4857 DNSQuestion *const q = m->NewQuestions; // Grab the question we're going to answer
4858#if USE_DNS64
4859 if (!mDNSOpaque16IsZero(q->TargetQID)) DNS64HandleNewQuestion(m, q);
4860#endif
4861 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
4862 mDNSBool AnsweredFromCache = mDNSfalse;
4863
4864 verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
4865
4866 if (cg) CheckCacheExpiration(m, HashSlotFromNameHash(q->qnamehash), cg);
4867 if (m->NewQuestions != q) { LogInfo("AnswerNewQuestion: Question deleted while doing CheckCacheExpiration"); goto exit; }
4868 m->NewQuestions = q->next;
4869 // Advance NewQuestions to the next *after* calling CheckCacheExpiration, because if we advance it first
4870 // then CheckCacheExpiration may give this question add/remove callbacks, and it's not yet ready for that.
4871 //
4872 // Also, CheckCacheExpiration() calls CacheRecordDeferredAdd() and CacheRecordRmv(), which invoke
4873 // client callbacks, which may delete their own or any other question. Our mechanism for detecting
4874 // whether our current m->NewQuestions question got deleted by one of these callbacks is to store the
4875 // value of m->NewQuestions in 'q' before calling CheckCacheExpiration(), and then verify afterwards
4876 // that they're still the same. If m->NewQuestions has changed (because mDNS_StopQuery_internal
4877 // advanced it), that means the question was deleted, so we no longer need to worry about answering
4878 // it (and indeed 'q' is now a dangling pointer, so dereferencing it at all would be bad, and the
4879 // values we computed for slot and cg are now stale and relate to a question that no longer exists).
4880 //
4881 // We can't use the usual m->CurrentQuestion mechanism for this because CacheRecordDeferredAdd() and
4882 // CacheRecordRmv() both use that themselves when walking the list of (non-new) questions generating callbacks.
4883 // Fortunately mDNS_StopQuery_internal auto-advances both m->CurrentQuestion *AND* m->NewQuestions when
4884 // deleting a question, so luckily we have an easy alternative way of detecting if our question got deleted.
4885
4886 if (m->lock_rrcache) LogMsg("AnswerNewQuestion ERROR! Cache already locked!");
4887 // This should be safe, because calling the client's question callback may cause the
4888 // question list to be modified, but should not ever cause the rrcache list to be modified.
4889 // If the client's question callback deletes the question, then m->CurrentQuestion will
4890 // be advanced, and we'll exit out of the loop
4891 m->lock_rrcache = 1;
4892 if (m->CurrentQuestion)
4893 LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set: %##s (%s)",
4894 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
4895 m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted
4896
4897 if (q->NoAnswer == NoAnswer_Fail)
4898 {
4899 LogMsg("AnswerNewQuestion: NoAnswer_Fail %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
4900 MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, mDNSInterface_Any, q->qDNSServer);
4901 q->NoAnswer = NoAnswer_Normal; // Temporarily turn off answer suppression
4902 AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, QC_addnocache);
4903 // Don't touch the question if it has been stopped already
4904 if (m->CurrentQuestion == q) q->NoAnswer = NoAnswer_Fail; // Restore NoAnswer state
4905 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
4906 }
4907
4908 if (m->CurrentQuestion != q)
4909 {
4910 LogInfo("AnswerNewQuestion: Question deleted while generating NoAnswer_Fail response");
4911 goto exit;
4912 }
4913
4914 // See if we want to tell it about LocalOnly/P2P records. If we answered them using LocalOnly
4915 // or P2P record, then we are done.
4916 if (AnswerQuestionWithLORecord(m, q, mDNSfalse))
4917 goto exit;
4918
4919 // If we are not supposed to answer this question, generate a negative response.
4920 // Temporarily suspend the SuppressQuery so that AnswerCurrentQuestionWithResourceRecord can answer the question
4921 //
4922 // If it is a question trying to validate some response, it already checked the cache for a response. If it still
4923 // reissues a question it means it could not find the RRSIGs. So, we need to bypass the cache check and send
4924 // the question out.
4925 if (QuerySuppressed(q))
4926 {
4927 AnswerSuppressedQuestion(m, q);
4928 }
4929 else if (!q->ValidatingResponse)
4930 {
4931 CacheRecord *rr;
4932 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
4933 if (SameNameRecordAnswersQuestion(&rr->resrec, q))
4934 {
4935 // SecsSinceRcvd is whole number of elapsed seconds, rounded down
4936 mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
4937 if (rr->resrec.rroriginalttl <= SecsSinceRcvd)
4938 {
4939 LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %s %d %d",
4940 rr->resrec.rroriginalttl, SecsSinceRcvd, CRDisplayString(m, rr), m->timenow, rr->TimeRcvd);
4941 continue; // Go to next one in loop
4942 }
4943
4944 // If this record set is marked unique, then that means we can reasonably assume we have the whole set
4945 // -- we don't need to rush out on the network and query immediately to see if there are more answers out there
4946 if ((rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) || (q->ExpectUnique))
4947 ShouldQueryImmediately = mDNSfalse;
4948 q->CurrentAnswers++;
4949 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
4950 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
4951 AnsweredFromCache = mDNStrue;
4952 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
4953 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
4954 }
4955 else if (mDNSOpaque16IsZero(q->TargetQID) && RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype))
4956 ShouldQueryImmediately = mDNSfalse;
4957 }
4958 // We don't use LogInfo for this "Question deleted" message because it happens so routinely that
4959 // it's not remotely remarkable, and therefore unlikely to be of much help tracking down bugs.
4960 if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving cache answers"); goto exit; }
4961
4962 // Neither a local record nor a cache entry could answer this question. If this question need to be retried
4963 // with search domains, generate a negative response which will now retry after appending search domains.
4964 // If the query was suppressed above, we already generated a negative response. When it gets unsuppressed,
4965 // we will retry with search domains.
4966 if (!QuerySuppressed(q) && !AnsweredFromCache && q->RetryWithSearchDomains)
4967 {
4968 LogInfo("AnswerNewQuestion: Generating response for retrying with search domains %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
4969 GenerateNegativeResponse(m, mDNSInterface_Any, QC_forceresponse);
4970 }
4971
4972 if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving negative answer"); goto exit; }
4973
4974 // Note: When a query gets suppressed or retried with search domains, we de-activate the question.
4975 // Hence we don't execute the following block of code for those cases.
4976 if (ShouldQueryImmediately && ActiveQuestion(q))
4977 {
4978 debugf("AnswerNewQuestion: ShouldQueryImmediately %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
4979 q->ThisQInterval = InitialQuestionInterval;
4980 q->LastQTime = m->timenow - q->ThisQInterval;
4981 if (mDNSOpaque16IsZero(q->TargetQID)) // For mDNS, spread packets to avoid a burst of simultaneous queries
4982 {
4983 // Compute random delay in the range 1-6 seconds, then divide by 50 to get 20-120ms
4984 if (!m->RandomQueryDelay)
4985 m->RandomQueryDelay = (mDNSPlatformOneSecond + mDNSRandom(mDNSPlatformOneSecond*5) - 1) / 50 + 1;
4986 q->LastQTime += m->RandomQueryDelay;
4987 }
4988 }
4989
4990 // IN ALL CASES make sure that m->NextScheduledQuery is set appropriately.
4991 // In cases where m->NewQuestions->DelayAnswering is set, we may have delayed generating our
4992 // answers for this question until *after* its scheduled transmission time, in which case
4993 // m->NextScheduledQuery may now be set to 'never', and in that case -- even though we're *not* doing
4994 // ShouldQueryImmediately -- we still need to make sure we set m->NextScheduledQuery correctly.
4995 SetNextQueryTime(m,q);
4996
4997exit:
4998 m->CurrentQuestion = mDNSNULL;
4999 m->lock_rrcache = 0;
5000}
5001
5002// When a NewLocalOnlyQuestion is created, AnswerNewLocalOnlyQuestion runs though our ResourceRecords delivering any
5003// appropriate answers, stopping if it reaches a NewLocalOnlyRecord -- these will be handled by AnswerAllLocalQuestionsWithLocalAuthRecord
5004mDNSlocal void AnswerNewLocalOnlyQuestion(mDNS *const m)
5005{
5006 AuthGroup *ag;
5007 DNSQuestion *q = m->NewLocalOnlyQuestions; // Grab the question we're going to answer
5008 mDNSBool retEv = mDNSfalse;
5009 m->NewLocalOnlyQuestions = q->next; // Advance NewLocalOnlyQuestions to the next (if any)
5010
5011 debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
5012
5013 if (m->CurrentQuestion)
5014 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentQuestion already set: %##s (%s)",
5015 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
5016 m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted
5017
5018 if (m->CurrentRecord)
5019 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
5020
5021 // 1. First walk the LocalOnly records answering the LocalOnly question
5022 // 2. As LocalOnly questions should also be answered by any other Auth records local to the machine,
5023 // walk the ResourceRecords list delivering the answers
5024 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname);
5025 if (ag)
5026 {
5027 m->CurrentRecord = ag->members;
5028 while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords)
5029 {
5030 AuthRecord *rr = m->CurrentRecord;
5031 m->CurrentRecord = rr->next;
5032 if (LocalOnlyRecordAnswersQuestion(rr, q))
5033 {
5034 retEv = mDNStrue;
5035 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue);
5036 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
5037 }
5038 }
5039 }
5040
5041 if (m->CurrentQuestion == q)
5042 {
5043 m->CurrentRecord = m->ResourceRecords;
5044
5045 while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords)
5046 {
5047 AuthRecord *rr = m->CurrentRecord;
5048 m->CurrentRecord = rr->next;
5049 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
5050 {
5051 retEv = mDNStrue;
5052 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue);
5053 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
5054 }
5055 }
5056 }
5057
5058 // The local host is the authoritative source for LocalOnly questions
5059 // so if no records exist and client requested intermediates, then generate a negative response
5060 if (!retEv && (m->CurrentQuestion == q) && q->ReturnIntermed)
5061 GenerateNegativeResponse(m, mDNSInterface_LocalOnly, QC_forceresponse);
5062
5063 m->CurrentQuestion = mDNSNULL;
5064 m->CurrentRecord = mDNSNULL;
5065}
5066
5067mDNSlocal CacheEntity *GetCacheEntity(mDNS *const m, const CacheGroup *const PreserveCG)
5068{
5069 CacheEntity *e = mDNSNULL;
5070
5071 if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); }
5072 m->lock_rrcache = 1;
5073
5074 // If we have no free records, ask the client layer to give us some more memory
5075 if (!m->rrcache_free && m->MainCallback)
5076 {
5077 if (m->rrcache_totalused != m->rrcache_size)
5078 LogMsg("GetFreeCacheRR: count mismatch: m->rrcache_totalused %lu != m->rrcache_size %lu",
5079 m->rrcache_totalused, m->rrcache_size);
5080
5081 // We don't want to be vulnerable to a malicious attacker flooding us with an infinite
5082 // number of bogus records so that we keep growing our cache until the machine runs out of memory.
5083 // To guard against this, if our cache grows above 512kB (approx 3168 records at 164 bytes each),
5084 // and we're actively using less than 1/32 of that cache, then we purge all the unused records
5085 // and recycle them, instead of allocating more memory.
5086 if (m->rrcache_size > 5000 && m->rrcache_size / 32 > m->rrcache_active)
5087 LogInfo("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
5088 m->rrcache_size, m->rrcache_active);
5089 else
5090 {
5091 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
5092 m->MainCallback(m, mStatus_GrowCache);
5093 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
5094 }
5095 }
5096
5097 // If we still have no free records, recycle all the records we can.
5098 // Enumerating the entire cache is moderately expensive, so when we do it, we reclaim all the records we can in one pass.
5099 if (!m->rrcache_free)
5100 {
5101 mDNSu32 oldtotalused = m->rrcache_totalused;
5102 mDNSu32 slot;
5103 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
5104 {
5105 CacheGroup **cp = &m->rrcache_hash[slot];
5106 while (*cp)
5107 {
5108 CacheRecord **rp = &(*cp)->members;
5109 while (*rp)
5110 {
5111 // Records that answer still-active questions are not candidates for recycling
5112 // Records that are currently linked into the CacheFlushRecords list may not be recycled, or we'll crash
5113 if ((*rp)->CRActiveQuestion || (*rp)->NextInCFList)
5114 rp=&(*rp)->next;
5115 else
5116 {
5117 CacheRecord *rr = *rp;
5118 *rp = (*rp)->next; // Cut record from list
5119 ReleaseCacheRecord(m, rr);
5120 }
5121 }
5122 if ((*cp)->rrcache_tail != rp)
5123 verbosedebugf("GetFreeCacheRR: Updating rrcache_tail[%lu] from %p to %p", slot, (*cp)->rrcache_tail, rp);
5124 (*cp)->rrcache_tail = rp;
5125 if ((*cp)->members || (*cp)==PreserveCG) cp=&(*cp)->next;
5126 else ReleaseCacheGroup(m, cp);
5127 }
5128 }
5129 LogInfo("GetCacheEntity recycled %d records to reduce cache from %d to %d",
5130 oldtotalused - m->rrcache_totalused, oldtotalused, m->rrcache_totalused);
5131 }
5132
5133 if (m->rrcache_free) // If there are records in the free list, take one
5134 {
5135 e = m->rrcache_free;
5136 m->rrcache_free = e->next;
5137 if (++m->rrcache_totalused >= m->rrcache_report)
5138 {
5139 LogInfo("RR Cache now using %ld objects", m->rrcache_totalused);
5140 if (m->rrcache_report < 100) m->rrcache_report += 10;
5141 else if (m->rrcache_report < 1000) m->rrcache_report += 100;
5142 else m->rrcache_report += 1000;
5143 }
5144 mDNSPlatformMemZero(e, sizeof(*e));
5145 }
5146
5147 m->lock_rrcache = 0;
5148
5149 return(e);
5150}
5151
5152mDNSlocal CacheRecord *GetCacheRecord(mDNS *const m, CacheGroup *cg, mDNSu16 RDLength)
5153{
5154 CacheRecord *r = (CacheRecord *)GetCacheEntity(m, cg);
5155 if (r)
5156 {
5157 r->resrec.rdata = (RData*)&r->smallrdatastorage; // By default, assume we're usually going to be using local storage
5158 if (RDLength > InlineCacheRDSize) // If RDLength is too big, allocate extra storage
5159 {
5160 r->resrec.rdata = (RData*)mDNSPlatformMemAllocate(sizeofRDataHeader + RDLength);
5161 if (r->resrec.rdata) r->resrec.rdata->MaxRDLength = r->resrec.rdlength = RDLength;
5162 else { ReleaseCacheEntity(m, (CacheEntity*)r); r = mDNSNULL; }
5163 }
5164 }
5165 return(r);
5166}
5167
5168mDNSlocal CacheGroup *GetCacheGroup(mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr)
5169{
5170 mDNSu16 namelen = DomainNameLength(rr->name);
5171 CacheGroup *cg = (CacheGroup*)GetCacheEntity(m, mDNSNULL);
5172 if (!cg) { LogMsg("GetCacheGroup: Failed to allocate memory for %##s", rr->name->c); return(mDNSNULL); }
5173 cg->next = m->rrcache_hash[slot];
5174 cg->namehash = rr->namehash;
5175 cg->members = mDNSNULL;
5176 cg->rrcache_tail = &cg->members;
5177 if (namelen > sizeof(cg->namestorage))
5178 cg->name = mDNSPlatformMemAllocate(namelen);
5179 else
5180 cg->name = (domainname*)cg->namestorage;
5181 if (!cg->name)
5182 {
5183 LogMsg("GetCacheGroup: Failed to allocate name storage for %##s", rr->name->c);
5184 ReleaseCacheEntity(m, (CacheEntity*)cg);
5185 return(mDNSNULL);
5186 }
5187 AssignDomainName(cg->name, rr->name);
5188
5189 if (CacheGroupForRecord(m, rr)) LogMsg("GetCacheGroup: Already have CacheGroup for %##s", rr->name->c);
5190 m->rrcache_hash[slot] = cg;
5191 if (CacheGroupForRecord(m, rr) != cg) LogMsg("GetCacheGroup: Not finding CacheGroup for %##s", rr->name->c);
5192
5193 return(cg);
5194}
5195
5196mDNSexport void mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr)
5197{
5198 mDNS_CheckLock(m);
5199
5200 // Make sure we mark this record as thoroughly expired -- we don't ever want to give
5201 // a positive answer using an expired record (e.g. from an interface that has gone away).
5202 // We don't want to clear CRActiveQuestion here, because that would leave the record subject to
5203 // summary deletion without giving the proper callback to any questions that are monitoring it.
5204 // By setting UnansweredQueries to MaxUnansweredQueries we ensure it won't trigger any further expiration queries.
5205 rr->TimeRcvd = m->timenow - mDNSPlatformOneSecond * 60;
5206 rr->UnansweredQueries = MaxUnansweredQueries;
5207 rr->resrec.rroriginalttl = 0;
5208 SetNextCacheCheckTimeForRecord(m, rr);
5209}
5210
5211mDNSexport mDNSs32 mDNS_TimeNow(const mDNS *const m)
5212{
5213 mDNSs32 time;
5214 mDNSPlatformLock(m);
5215 if (m->mDNS_busy)
5216 {
5217 LogMsg("mDNS_TimeNow called while holding mDNS lock. This is incorrect. Code protected by lock should just use m->timenow.");
5218 if (!m->timenow) LogMsg("mDNS_TimeNow: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy);
5219 }
5220
5221 if (m->timenow) time = m->timenow;
5222 else time = mDNS_TimeNow_NoLock(m);
5223 mDNSPlatformUnlock(m);
5224 return(time);
5225}
5226
5227// To avoid pointless CPU thrash, we use SetSPSProxyListChanged(X) to record the last interface that
5228// had its Sleep Proxy client list change, and defer to actual BPF reconfiguration to mDNS_Execute().
5229// (GetNextScheduledEvent() returns "now" when m->SPSProxyListChanged is set)
5230#define SetSPSProxyListChanged(X) do { \
5231 if (m->SPSProxyListChanged && m->SPSProxyListChanged != (X)) mDNSPlatformUpdateProxyList(m->SPSProxyListChanged); \
5232 m->SPSProxyListChanged = (X); } while(0)
5233
5234// Called from mDNS_Execute() to expire stale proxy records
5235mDNSlocal void CheckProxyRecords(mDNS *const m, AuthRecord *list)
5236{
5237 m->CurrentRecord = list;
5238 while (m->CurrentRecord)
5239 {
5240 AuthRecord *rr = m->CurrentRecord;
5241 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering && rr->WakeUp.HMAC.l[0])
5242 {
5243 // If m->SPSSocket is NULL that means we're not acting as a sleep proxy any more,
5244 // so we need to cease proxying for *all* records we may have, expired or not.
5245 if (m->SPSSocket && m->timenow - rr->TimeExpire < 0) // If proxy record not expired yet, update m->NextScheduledSPS
5246 {
5247 if (m->NextScheduledSPS - rr->TimeExpire > 0)
5248 m->NextScheduledSPS = rr->TimeExpire;
5249 }
5250 else // else proxy record expired, so remove it
5251 {
5252 LogSPS("CheckProxyRecords: Removing %d H-MAC %.6a I-MAC %.6a %d %s",
5253 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, ARDisplayString(m, rr));
5254 SetSPSProxyListChanged(rr->resrec.InterfaceID);
5255 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
5256 // Don't touch rr after this -- memory may have been free'd
5257 }
5258 }
5259 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
5260 // new records could have been added to the end of the list as a result of that call.
5261 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
5262 m->CurrentRecord = rr->next;
5263 }
5264}
5265
5266mDNSlocal void CheckRmvEventsForLocalRecords(mDNS *const m)
5267{
5268 while (m->CurrentRecord)
5269 {
5270 AuthRecord *rr = m->CurrentRecord;
5271 if (rr->AnsweredLocalQ && rr->resrec.RecordType == kDNSRecordTypeDeregistering)
5272 {
5273 debugf("CheckRmvEventsForLocalRecords: Generating local RMV events for %s", ARDisplayString(m, rr));
5274 rr->resrec.RecordType = kDNSRecordTypeShared;
5275 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse);
5276 if (m->CurrentRecord == rr) // If rr still exists in list, restore its state now
5277 {
5278 rr->resrec.RecordType = kDNSRecordTypeDeregistering;
5279 rr->AnsweredLocalQ = mDNSfalse;
5280 // SendResponses normally calls CompleteDeregistration after sending goodbyes.
5281 // For LocalOnly records, we don't do that and hence we need to do that here.
5282 if (RRLocalOnly(rr)) CompleteDeregistration(m, rr);
5283 }
5284 }
5285 if (m->CurrentRecord == rr) // If m->CurrentRecord was not auto-advanced, do it ourselves now
5286 m->CurrentRecord = rr->next;
5287 }
5288}
5289
5290mDNSlocal void TimeoutQuestions_internal(mDNS *const m, DNSQuestion* questions, mDNSInterfaceID InterfaceID)
5291{
5292 if (m->CurrentQuestion)
5293 LogMsg("TimeoutQuestions ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c,
5294 DNSTypeName(m->CurrentQuestion->qtype));
5295 m->CurrentQuestion = questions;
5296 while (m->CurrentQuestion)
5297 {
5298 DNSQuestion *const q = m->CurrentQuestion;
5299 if (q->StopTime)
5300 {
5301 if (!q->TimeoutQuestion)
5302 LogMsg("TimeoutQuestions: ERROR!! TimeoutQuestion not set, but StopTime set for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
5303
5304 if (m->timenow - q->StopTime >= 0)
5305 {
5306 LogInfo("TimeoutQuestions: question %p %##s timed out, time %d", q, q->qname.c, m->timenow - q->StopTime);
5307 q->LOAddressAnswers = 0; // unset since timing out the question
5308 GenerateNegativeResponse(m, InterfaceID, QC_forceresponse);
5309 if (m->CurrentQuestion == q) q->StopTime = 0;
5310 }
5311 else
5312 {
5313 if (m->NextScheduledStopTime - q->StopTime > 0)
5314 m->NextScheduledStopTime = q->StopTime;
5315 }
5316 }
5317 // If m->CurrentQuestion wasn't modified out from under us, advance it now
5318 // We can't do this at the start of the loop because GenerateNegativeResponse
5319 // depends on having m->CurrentQuestion point to the right question
5320 if (m->CurrentQuestion == q)
5321 m->CurrentQuestion = q->next;
5322 }
5323 m->CurrentQuestion = mDNSNULL;
5324}
5325
5326mDNSlocal void TimeoutQuestions(mDNS *const m)
5327{
5328 m->NextScheduledStopTime = m->timenow + FutureTime; // push reschedule of TimeoutQuestions to way off into the future
5329 TimeoutQuestions_internal(m, m->Questions, mDNSInterface_Any);
5330 TimeoutQuestions_internal(m, m->LocalOnlyQuestions, mDNSInterface_LocalOnly);
5331}
5332
5333mDNSlocal void mDNSCoreFreeProxyRR(mDNS *const m)
5334{
5335 AuthRecord *rrPtr = m->SPSRRSet, *rrNext = mDNSNULL;
5336 LogSPS("%s : Freeing stored sleep proxy A/AAAA records", __func__);
5337 while (rrPtr)
5338 {
5339 rrNext = rrPtr->next;
5340 mDNSPlatformMemFree(rrPtr);
5341 rrPtr = rrNext;
5342 }
5343 m->SPSRRSet = mDNSNULL;
5344}
5345
5346mDNSexport mDNSs32 mDNS_Execute(mDNS *const m)
5347{
5348 mDNS_Lock(m); // Must grab lock before trying to read m->timenow
5349
5350 if (m->timenow - m->NextScheduledEvent >= 0)
5351 {
5352 int i;
5353 AuthRecord *head, *tail;
5354 mDNSu32 slot;
5355 AuthGroup *ag;
5356
5357 verbosedebugf("mDNS_Execute");
5358
5359 if (m->CurrentQuestion)
5360 LogMsg("mDNS_Execute: ERROR m->CurrentQuestion already set: %##s (%s)",
5361 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
5362
5363 if (m->CurrentRecord)
5364 LogMsg("mDNS_Execute: ERROR m->CurrentRecord already set: %s", ARDisplayString(m, m->CurrentRecord));
5365
5366 // 1. If we're past the probe suppression time, we can clear it
5367 if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0;
5368
5369 // 2. If it's been more than ten seconds since the last probe failure, we can clear the counter
5370 if (m->NumFailedProbes && m->timenow - m->ProbeFailTime >= mDNSPlatformOneSecond * 10) m->NumFailedProbes = 0;
5371
5372 // 3. Purge our cache of stale old records
5373 if (m->rrcache_size && m->timenow - m->NextCacheCheck >= 0)
5374 {
5375 mDNSu32 numchecked = 0;
5376 m->NextCacheCheck = m->timenow + FutureTime;
5377 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
5378 {
5379 if (m->timenow - m->rrcache_nextcheck[slot] >= 0)
5380 {
5381 CacheGroup **cp = &m->rrcache_hash[slot];
5382 m->rrcache_nextcheck[slot] = m->timenow + FutureTime;
5383 while (*cp)
5384 {
5385 debugf("m->NextCacheCheck %4d Slot %3d %##s", numchecked, slot, *cp ? (*cp)->name : (domainname*)"\x04NULL");
5386 numchecked++;
5387 CheckCacheExpiration(m, slot, *cp);
5388 if ((*cp)->members) cp=&(*cp)->next;
5389 else ReleaseCacheGroup(m, cp);
5390 }
5391 }
5392 // Even if we didn't need to actually check this slot yet, still need to
5393 // factor its nextcheck time into our overall NextCacheCheck value
5394 if (m->NextCacheCheck - m->rrcache_nextcheck[slot] > 0)
5395 m->NextCacheCheck = m->rrcache_nextcheck[slot];
5396 }
5397 debugf("m->NextCacheCheck %4d checked, next in %d", numchecked, m->NextCacheCheck - m->timenow);
5398 }
5399
5400 if (m->timenow - m->NextScheduledSPS >= 0)
5401 {
5402 m->NextScheduledSPS = m->timenow + FutureTime;
5403 CheckProxyRecords(m, m->DuplicateRecords); // Clear m->DuplicateRecords first, then m->ResourceRecords
5404 CheckProxyRecords(m, m->ResourceRecords);
5405 }
5406
5407 SetSPSProxyListChanged(mDNSNULL); // Perform any deferred BPF reconfiguration now
5408
5409 // Check to see if we need to send any keepalives. Do this after we called CheckProxyRecords above
5410 // as records could have expired during that check
5411 if (m->timenow - m->NextScheduledKA >= 0)
5412 {
5413 m->NextScheduledKA = m->timenow + FutureTime;
5414 mDNS_SendKeepalives(m);
5415 }
5416
5417#if BONJOUR_ON_DEMAND
5418 if (m->NextBonjourDisableTime && (m->timenow - m->NextBonjourDisableTime >= 0))
5419 {
5420 // Schedule immediate network change processing to leave the multicast group
5421 // since the delay time has expired since the previous active registration or query.
5422 m->NetworkChanged = m->timenow;
5423 m->NextBonjourDisableTime = 0;
5424 m->BonjourEnabled = 0;
5425
5426 LogInfo("mDNS_Execute: Scheduled network changed processing to leave multicast group.");
5427 }
5428#endif // BONJOUR_ON_DEMAND
5429
5430 // Clear AnnounceOwner if necessary. (Do this *before* SendQueries() and SendResponses().)
5431 if (m->AnnounceOwner && m->timenow - m->AnnounceOwner >= 0)
5432 {
5433 m->AnnounceOwner = 0;
5434
5435 // This is a good time to reset the delay counter used to prevent spurious conflicts
5436 m->DelayConflictProcessing = 0;
5437 }
5438
5439 if (m->DelaySleep && m->timenow - m->DelaySleep >= 0)
5440 {
5441 m->DelaySleep = 0;
5442 if (m->SleepState == SleepState_Transferring)
5443 {
5444 LogSPS("Re-sleep delay passed; now checking for Sleep Proxy Servers");
5445 BeginSleepProcessing(m);
5446 }
5447 }
5448
5449 // 4. See if we can answer any of our new local questions from the cache
5450 for (i=0; m->NewQuestions && i<1000; i++)
5451 {
5452 if (m->NewQuestions->DelayAnswering && m->timenow - m->NewQuestions->DelayAnswering < 0) break;
5453 AnswerNewQuestion(m);
5454 }
5455 if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
5456
5457 // Make sure we deliver *all* local RMV events, and clear the corresponding rr->AnsweredLocalQ flags, *before*
5458 // we begin generating *any* new ADD events in the m->NewLocalOnlyQuestions and m->NewLocalRecords loops below.
5459 for (i=0; i<1000 && m->LocalRemoveEvents; i++)
5460 {
5461 m->LocalRemoveEvents = mDNSfalse;
5462 m->CurrentRecord = m->ResourceRecords;
5463 CheckRmvEventsForLocalRecords(m);
5464 // Walk the LocalOnly records and deliver the RMV events
5465 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
5466 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
5467 {
5468 m->CurrentRecord = ag->members;
5469 if (m->CurrentRecord) CheckRmvEventsForLocalRecords(m);
5470 }
5471 }
5472
5473 if (i >= 1000) LogMsg("mDNS_Execute: m->LocalRemoveEvents exceeded loop limit");
5474
5475 for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m);
5476 if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
5477
5478 head = tail = mDNSNULL;
5479 for (i=0; i<1000 && m->NewLocalRecords && m->NewLocalRecords != head; i++)
5480 {
5481 AuthRecord *rr = m->NewLocalRecords;
5482 m->NewLocalRecords = m->NewLocalRecords->next;
5483 if (LocalRecordReady(rr))
5484 {
5485 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m, rr));
5486 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue);
5487 }
5488 else if (!rr->next)
5489 {
5490 // If we have just one record that is not ready, we don't have to unlink and
5491 // reinsert. As the NewLocalRecords will be NULL for this case, the loop will
5492 // terminate and set the NewLocalRecords to rr.
5493 debugf("mDNS_Execute: Just one LocalAuthRecord %s, breaking out of the loop early", ARDisplayString(m, rr));
5494 if (head != mDNSNULL || m->NewLocalRecords != mDNSNULL)
5495 LogMsg("mDNS_Execute: ERROR!!: head %p, NewLocalRecords %p", head, m->NewLocalRecords);
5496
5497 head = rr;
5498 }
5499 else
5500 {
5501 AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records
5502 debugf("mDNS_Execute: Skipping LocalAuthRecord %s", ARDisplayString(m, rr));
5503 // if this is the first record we are skipping, move to the end of the list.
5504 // if we have already skipped records before, append it at the end.
5505 while (*p && *p != rr) p=&(*p)->next;
5506 if (*p) *p = rr->next; // Cut this record from the list
5507 else { LogMsg("mDNS_Execute: ERROR!! Cannot find record %s in ResourceRecords list", ARDisplayString(m, rr)); break; }
5508 if (!head)
5509 {
5510 while (*p) p=&(*p)->next;
5511 *p = rr;
5512 head = tail = rr;
5513 }
5514 else
5515 {
5516 tail->next = rr;
5517 tail = rr;
5518 }
5519 rr->next = mDNSNULL;
5520 }
5521 }
5522 m->NewLocalRecords = head;
5523 debugf("mDNS_Execute: Setting NewLocalRecords to %s", (head ? ARDisplayString(m, head) : "NULL"));
5524
5525 if (i >= 1000) LogMsg("mDNS_Execute: m->NewLocalRecords exceeded loop limit");
5526
5527 // Check to see if we have any new LocalOnly/P2P records to examine for delivering
5528 // to our local questions
5529 if (m->NewLocalOnlyRecords)
5530 {
5531 m->NewLocalOnlyRecords = mDNSfalse;
5532 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
5533 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
5534 {
5535 for (i=0; i<100 && ag->NewLocalOnlyRecords; i++)
5536 {
5537 AuthRecord *rr = ag->NewLocalOnlyRecords;
5538 ag->NewLocalOnlyRecords = ag->NewLocalOnlyRecords->next;
5539 // LocalOnly records should always be ready as they never probe
5540 if (LocalRecordReady(rr))
5541 {
5542 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m, rr));
5543 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue);
5544 }
5545 else LogMsg("mDNS_Execute: LocalOnlyRecord %s not ready", ARDisplayString(m, rr));
5546 }
5547 // We limit about 100 per AuthGroup that can be serviced at a time
5548 if (i >= 100) LogMsg("mDNS_Execute: ag->NewLocalOnlyRecords exceeded loop limit");
5549 }
5550 }
5551
5552 // 5. See what packets we need to send
5553 if (m->mDNSPlatformStatus != mStatus_NoError || (m->SleepState == SleepState_Sleeping))
5554 DiscardDeregistrations(m);
5555 if (m->mDNSPlatformStatus == mStatus_NoError && (m->SuppressSending == 0 || m->timenow - m->SuppressSending >= 0))
5556 {
5557 // If the platform code is ready, and we're not suppressing packet generation right now
5558 // then send our responses, probes, and questions.
5559 // We check the cache first, because there might be records close to expiring that trigger questions to refresh them.
5560 // We send queries next, because there might be final-stage probes that complete their probing here, causing
5561 // them to advance to announcing state, and we want those to be included in any announcements we send out.
5562 // Finally, we send responses, including the previously mentioned records that just completed probing.
5563 m->SuppressSending = 0;
5564
5565 // 6. Send Query packets. This may cause some probing records to advance to announcing state
5566 if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m);
5567 if (m->timenow - m->NextScheduledQuery >= 0)
5568 {
5569 DNSQuestion *q;
5570 LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second",
5571 m->timenow, m->NextScheduledQuery, m->timenow - m->NextScheduledQuery);
5572 m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond;
5573 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
5574 if (ActiveQuestion(q) && m->timenow - NextQSendTime(q) >= 0)
5575 LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
5576 }
5577 if (m->timenow - m->NextScheduledProbe >= 0)
5578 {
5579 LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second",
5580 m->timenow, m->NextScheduledProbe, m->timenow - m->NextScheduledProbe);
5581 m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond;
5582 }
5583
5584 // 7. Send Response packets, including probing records just advanced to announcing state
5585 if (m->timenow - m->NextScheduledResponse >= 0) SendResponses(m);
5586 if (m->timenow - m->NextScheduledResponse >= 0)
5587 {
5588 LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second");
5589 m->NextScheduledResponse = m->timenow + mDNSPlatformOneSecond;
5590 }
5591 }
5592
5593 // Clear RandomDelay values, ready to pick a new different value next time
5594 m->RandomQueryDelay = 0;
5595 m->RandomReconfirmDelay = 0;
5596
5597 // See if any questions (or local-only questions) have timed out
5598 if (m->NextScheduledStopTime && m->timenow - m->NextScheduledStopTime >= 0) TimeoutQuestions(m);
5599#ifndef UNICAST_DISABLED
5600 if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0) UpdateAllSRVRecords(m);
5601 if (m->timenow - m->NextScheduledNATOp >= 0) CheckNATMappings(m);
5602 if (m->timenow - m->NextuDNSEvent >= 0) uDNS_Tasks(m);
5603#endif
5604#if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
5605 extern void serviceBLE();
5606 if (m->NextBLEServiceTime && (m->timenow - m->NextBLEServiceTime >= 0)) serviceBLE();
5607#endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
5608 }
5609
5610 // Note about multi-threaded systems:
5611 // On a multi-threaded system, some other thread could run right after the mDNS_Unlock(),
5612 // performing mDNS API operations that change our next scheduled event time.
5613 //
5614 // On multi-threaded systems (like the current Windows implementation) that have a single main thread
5615 // calling mDNS_Execute() (and other threads allowed to call mDNS API routines) it is the responsibility
5616 // of the mDNSPlatformUnlock() routine to signal some kind of stateful condition variable that will
5617 // signal whatever blocking primitive the main thread is using, so that it will wake up and execute one
5618 // more iteration of its loop, and immediately call mDNS_Execute() again. The signal has to be stateful
5619 // in the sense that if the main thread has not yet entered its blocking primitive, then as soon as it
5620 // does, the state of the signal will be noticed, causing the blocking primitive to return immediately
5621 // without blocking. This avoids the race condition between the signal from the other thread arriving
5622 // just *before* or just *after* the main thread enters the blocking primitive.
5623 //
5624 // On multi-threaded systems (like the current Mac OS 9 implementation) that are entirely timer-driven,
5625 // with no main mDNS_Execute() thread, it is the responsibility of the mDNSPlatformUnlock() routine to
5626 // set the timer according to the m->NextScheduledEvent value, and then when the timer fires, the timer
5627 // callback function should call mDNS_Execute() (and ignore the return value, which may already be stale
5628 // by the time it gets to the timer callback function).
5629
5630 mDNS_Unlock(m); // Calling mDNS_Unlock is what gives m->NextScheduledEvent its new value
5631 return(m->NextScheduledEvent);
5632}
5633
5634#ifndef UNICAST_DISABLED
5635mDNSlocal void SuspendLLQs(mDNS *m)
5636{
5637 DNSQuestion *q;
5638 for (q = m->Questions; q; q = q->next)
5639 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->state == LLQ_Established)
5640 { q->ReqLease = 0; sendLLQRefresh(m, q); }
5641}
5642#endif // UNICAST_DISABLED
5643
5644mDNSlocal mDNSBool QuestionHasLocalAnswers(mDNS *const m, DNSQuestion *q)
5645{
5646 AuthRecord *rr;
5647 AuthGroup *ag;
5648
5649 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname);
5650 if (ag)
5651 {
5652 for (rr = ag->members; rr; rr=rr->next)
5653 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME
5654 if (UniqueLocalOnlyRecord(rr) && LocalOnlyRecordAnswersQuestion(rr, q))
5655 {
5656 LogInfo("QuestionHasLocalAnswers: Question %p %##s (%s) has local answer %s", q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr));
5657 return mDNStrue;
5658 }
5659 }
5660 return mDNSfalse;
5661}
5662
5663// ActivateUnicastQuery() is called from three places:
5664// 1. When a new question is created
5665// 2. On wake from sleep
5666// 3. When the DNS configuration changes
5667// In case 1 we don't want to mess with our established ThisQInterval and LastQTime (ScheduleImmediately is false)
5668// In cases 2 and 3 we do want to cause the question to be resent immediately (ScheduleImmediately is true)
5669mDNSlocal void ActivateUnicastQuery(mDNS *const m, DNSQuestion *const question, mDNSBool ScheduleImmediately)
5670{
5671 // For now this AutoTunnel stuff is specific to Mac OS X.
5672 // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer
5673#if APPLE_OSX_mDNSResponder
5674 // Even though BTMM client tunnels are only useful for AAAA queries, we need to treat v4 and v6 queries equally.
5675 // Otherwise we can get the situation where the A query completes really fast (with an NXDOMAIN result) and the
5676 // caller then gives up waiting for the AAAA result while we're still in the process of setting up the tunnel.
5677 // To level the playing field, we block both A and AAAA queries while tunnel setup is in progress, and then
5678 // returns results for both at the same time. If we are looking for the _autotunnel6 record, then skip this logic
5679 // as this would trigger looking up _autotunnel6._autotunnel6 and end up failing the original query.
5680
5681 if (RRTypeIsAddressType(question->qtype) && PrivateQuery(question) &&
5682 !SameDomainLabel(question->qname.c, (const mDNSu8 *)"\x0c_autotunnel6")&& question->QuestionCallback != AutoTunnelCallback)
5683 {
5684 question->NoAnswer = NoAnswer_Suspended;
5685 AddNewClientTunnel(question);
5686 return;
5687 }
5688#endif // APPLE_OSX_mDNSResponder
5689
5690 if (!question->DuplicateOf)
5691 {
5692 debugf("ActivateUnicastQuery: %##s %s%s%s",
5693 question->qname.c, DNSTypeName(question->qtype), PrivateQuery(question) ? " (Private)" : "", ScheduleImmediately ? " ScheduleImmediately" : "");
5694 question->CNAMEReferrals = 0;
5695 if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; }
5696 if (question->LongLived)
5697 {
5698 question->state = LLQ_InitialRequest;
5699 question->id = zeroOpaque64;
5700 question->servPort = zeroIPPort;
5701 if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; }
5702 }
5703 // If the question has local answers, then we don't want answers from outside
5704 if (ScheduleImmediately && !QuestionHasLocalAnswers(m, question))
5705 {
5706 question->ThisQInterval = InitialQuestionInterval;
5707 question->LastQTime = m->timenow - question->ThisQInterval;
5708 SetNextQueryTime(m, question);
5709 }
5710 }
5711}
5712
5713// Caller should hold the lock
5714mDNSexport void mDNSCoreRestartAddressQueries(mDNS *const m, mDNSBool SearchDomainsChanged, FlushCache flushCacheRecords,
5715 CallbackBeforeStartQuery BeforeStartCallback, void *context)
5716{
5717 DNSQuestion *q;
5718 DNSQuestion *restart = mDNSNULL;
5719
5720 mDNS_CheckLock(m);
5721
5722 // 1. Flush the cache records
5723 if (flushCacheRecords) flushCacheRecords(m);
5724
5725 // 2. Even though we may have purged the cache records above, before it can generate RMV event
5726 // we are going to stop the question. Hence we need to deliver the RMV event before we
5727 // stop the question.
5728 //
5729 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the
5730 // application callback can potentially stop the current question (detected by CurrentQuestion) or
5731 // *any* other question which could be the next one that we may process here. RestartQuestion
5732 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal
5733 // if the "next" question is stopped while the CurrentQuestion is stopped
5734
5735 if (m->RestartQuestion)
5736 LogMsg("mDNSCoreRestartAddressQueries: ERROR!! m->RestartQuestion already set: %##s (%s)",
5737 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype));
5738
5739 m->RestartQuestion = m->Questions;
5740 while (m->RestartQuestion)
5741 {
5742 q = m->RestartQuestion;
5743 m->RestartQuestion = q->next;
5744 // GetZoneData questions are referenced by other questions (original query that started the GetZoneData
5745 // question) through their "nta" pointer. Normally when the original query stops, it stops the
5746 // GetZoneData question and also frees the memory (See CancelGetZoneData). If we stop the GetZoneData
5747 // question followed by the original query that refers to this GetZoneData question, we will end up
5748 // freeing the GetZoneData question and then start the "freed" question at the end.
5749
5750 if (IsGetZoneDataQuestion(q))
5751 {
5752 DNSQuestion *refq = q->next;
5753 LogInfo("mDNSCoreRestartAddressQueries: Skipping GetZoneDataQuestion %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
5754 // debug stuff, we just try to find the referencing question and don't do much with it
5755 while (refq)
5756 {
5757 if (q == &refq->nta->question)
5758 {
5759 LogInfo("mDNSCoreRestartAddressQueries: Question %p %##s (%s) referring to GetZoneDataQuestion %p, not stopping", refq, refq->qname.c, DNSTypeName(refq->qtype), q);
5760 }
5761 refq = refq->next;
5762 }
5763 continue;
5764 }
5765
5766 // This function is called when /etc/hosts changes and that could affect A, AAAA and CNAME queries
5767 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA && q->qtype != kDNSType_CNAME) continue;
5768
5769 // If the search domains did not change, then we restart all the queries. Otherwise, only
5770 // for queries for which we "might" have appended search domains ("might" because we may
5771 // find results before we apply search domains even though AppendSearchDomains is set to 1)
5772 if (!SearchDomainsChanged || q->AppendSearchDomains)
5773 {
5774 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero
5775 // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before
5776 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers). Let us say that
5777 // /etc/hosts has an A Record for web.apple.com. Any queries for web.apple.com will be answered locally.
5778 // But this can't prevent a CNAME/AAAA query to not to be sent on the wire. When it is sent on the wire,
5779 // it could create cache entries. When we are restarting queries, we can't deliver the cache RMV events
5780 // for the original query using these cache entries as ADDs were never delivered using these cache
5781 // entries and hence this order is needed.
5782
5783 // If the query is suppressed, the RMV events won't be delivered
5784 if (!CacheRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Cache Record RMV events"); continue; }
5785
5786 // SuppressQuery status does not affect questions that are answered using local records
5787 if (!LocalRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Local Record RMV events"); continue; }
5788
5789 LogInfo("mDNSCoreRestartAddressQueries: Stop question %p %##s (%s), AppendSearchDomains %d, qnameOrig %p", q,
5790 q->qname.c, DNSTypeName(q->qtype), q->AppendSearchDomains, q->qnameOrig);
5791 mDNS_StopQuery_internal(m, q);
5792 // Reset state so that it looks like it was in the beginning i.e it should look at /etc/hosts, cache
5793 // and then search domains should be appended. At the beginning, qnameOrig was NULL.
5794 if (q->qnameOrig)
5795 {
5796 LogInfo("mDNSCoreRestartAddressQueries: qnameOrig %##s", q->qnameOrig);
5797 AssignDomainName(&q->qname, q->qnameOrig);
5798 mDNSPlatformMemFree(q->qnameOrig);
5799 q->qnameOrig = mDNSNULL;
5800 q->RetryWithSearchDomains = ApplySearchDomainsFirst(q) ? 1 : 0;
5801 }
5802 q->SearchListIndex = 0;
5803 q->next = restart;
5804 restart = q;
5805 }
5806 }
5807
5808 // 3. Callback before we start the query
5809 if (BeforeStartCallback) BeforeStartCallback(m, context);
5810
5811 // 4. Restart all the stopped queries
5812 while (restart)
5813 {
5814 q = restart;
5815 restart = restart->next;
5816 q->next = mDNSNULL;
5817 LogInfo("mDNSCoreRestartAddressQueries: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
5818 mDNS_StartQuery_internal(m, q);
5819 }
5820}
5821
5822mDNSexport void mDNSCoreRestartQueries(mDNS *const m)
5823{
5824 DNSQuestion *q;
5825
5826#ifndef UNICAST_DISABLED
5827 // Retrigger all our uDNS questions
5828 if (m->CurrentQuestion)
5829 LogMsg("mDNSCoreRestartQueries: ERROR m->CurrentQuestion already set: %##s (%s)",
5830 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
5831 m->CurrentQuestion = m->Questions;
5832 while (m->CurrentQuestion)
5833 {
5834 q = m->CurrentQuestion;
5835 m->CurrentQuestion = m->CurrentQuestion->next;
5836 if (!mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) ActivateUnicastQuery(m, q, mDNStrue);
5837 }
5838#endif
5839
5840 // Retrigger all our mDNS questions
5841 for (q = m->Questions; q; q=q->next) // Scan our list of questions
5842 mDNSCoreRestartQuestion(m, q);
5843}
5844
5845// restart question if it's multicast and currently active
5846mDNSexport void mDNSCoreRestartQuestion(mDNS *const m, DNSQuestion *q)
5847{
5848 if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q))
5849 {
5850 q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question
5851 q->RequestUnicast = kDefaultRequestUnicastCount;
5852 q->LastQTime = m->timenow - q->ThisQInterval;
5853 q->RecentAnswerPkts = 0;
5854 ExpireDupSuppressInfo(q->DupSuppress, m->timenow);
5855 m->NextScheduledQuery = m->timenow;
5856 }
5857}
5858
5859// restart the probe/announce cycle for multicast record
5860mDNSexport void mDNSCoreRestartRegistration(mDNS *const m, AuthRecord *rr, int announceCount)
5861{
5862 if (!AuthRecord_uDNS(rr))
5863 {
5864 if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
5865 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
5866
5867 if (mDNS_KeepaliveRecord(&rr->resrec))
5868 {
5869 rr->AnnounceCount = 0; // Do not announce keepalive records
5870 }
5871 else
5872 {
5873 // announceCount < 0 indicates default announce count should be used
5874 if (announceCount < 0)
5875 announceCount = InitialAnnounceCount;
5876 if (rr->AnnounceCount < (mDNSu8)announceCount)
5877 rr->AnnounceCount = (mDNSu8)announceCount;
5878 }
5879
5880 rr->SendNSECNow = mDNSNULL;
5881 InitializeLastAPTime(m, rr);
5882 }
5883}
5884
5885// ***************************************************************************
5886#if COMPILER_LIKES_PRAGMA_MARK
5887#pragma mark -
5888#pragma mark - Power Management (Sleep/Wake)
5889#endif
5890
5891mDNSexport void mDNS_UpdateAllowSleep(mDNS *const m)
5892{
5893#ifndef IDLESLEEPCONTROL_DISABLED
5894 mDNSBool allowSleep = mDNStrue;
5895 char reason[128];
5896
5897 reason[0] = 0;
5898
5899 if (m->SystemSleepOnlyIfWakeOnLAN)
5900 {
5901 // Don't sleep if we are a proxy for any services
5902 if (m->ProxyRecords)
5903 {
5904 allowSleep = mDNSfalse;
5905 mDNS_snprintf(reason, sizeof(reason), "sleep proxy for %d records", m->ProxyRecords);
5906 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because we are proxying %d records", m->ProxyRecords);
5907 }
5908
5909 if (allowSleep && mDNSCoreHaveAdvertisedMulticastServices(m))
5910 {
5911 // Scan the list of active interfaces
5912 NetworkInterfaceInfo *intf;
5913 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
5914 {
5915 if (intf->McastTxRx && !intf->Loopback && !mDNSPlatformInterfaceIsD2D(intf->InterfaceID))
5916 {
5917 // Disallow sleep if this interface doesn't support NetWake
5918 if (!intf->NetWake)
5919 {
5920 allowSleep = mDNSfalse;
5921 mDNS_snprintf(reason, sizeof(reason), "%s does not support NetWake", intf->ifname);
5922 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s does not support NetWake", intf->ifname);
5923 break;
5924 }
5925
5926 // If the interface can be an in-NIC Proxy, we should check if it can accomodate all the records
5927 // that will be offloaded. If not, we should prevent sleep.
5928 // This check will be possible once the lower layers provide an API to query the space available for offloads on the NIC.
5929#if APPLE_OSX_mDNSResponder
5930 if (!SupportsInNICProxy(intf))
5931#endif
5932 {
5933 // Disallow sleep if there is no sleep proxy server
5934 const CacheRecord *cr = FindSPSInCache1(m, &intf->NetWakeBrowse, mDNSNULL, mDNSNULL);
5935 if ( cr == mDNSNULL)
5936 {
5937 allowSleep = mDNSfalse;
5938 mDNS_snprintf(reason, sizeof(reason), "No sleep proxy server on %s", intf->ifname);
5939 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s has no sleep proxy server", intf->ifname);
5940 break;
5941 }
5942 else if (m->SPSType != 0)
5943 {
5944 mDNSu32 mymetric = LocalSPSMetric(m);
5945 mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c);
5946 if (metric >= mymetric)
5947 {
5948 allowSleep = mDNSfalse;
5949 mDNS_snprintf(reason, sizeof(reason), "No sleep proxy server with better metric on %s", intf->ifname);
5950 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s has no sleep proxy server with a better metric", intf->ifname);
5951 break;
5952 }
5953 }
5954 }
5955 }
5956 }
5957 }
5958 }
5959
5960 // Call the platform code to enable/disable sleep
5961 mDNSPlatformSetAllowSleep(allowSleep, reason);
5962#else
5963 (void) m;
5964#endif /* !defined(IDLESLEEPCONTROL_DISABLED) */
5965}
5966
5967mDNSlocal mDNSBool mDNSUpdateOkToSend(mDNS *const m, AuthRecord *rr, NetworkInterfaceInfo *const intf, mDNSu32 scopeid)
5968{
5969 // If it is not a uDNS record, check to see if the updateid is zero. "updateid" is cleared when we have
5970 // sent the resource record on all the interfaces. If the update id is not zero, check to see if it is time
5971 // to send.
5972 if (AuthRecord_uDNS(rr) || (rr->AuthFlags & AuthFlagsWakeOnly) || mDNSOpaque16IsZero(rr->updateid) ||
5973 m->timenow - (rr->LastAPTime + rr->ThisAPInterval) < 0)
5974 {
5975 return mDNSfalse;
5976 }
5977
5978 // If we have a pending registration for "scopeid", it is ok to send the update on that interface.
5979 // If the scopeid is too big to check for validity, we don't check against updateIntID. When
5980 // we successfully update on all the interfaces (with whatever set in "rr->updateIntID"), we clear
5981 // updateid and we should have returned from above.
5982 //
5983 // Note: scopeid is the same as intf->InterfaceID. It is passed in so that we don't have to call the
5984 // platform function to extract the value from "intf" every time.
5985
5986 if ((scopeid >= (sizeof(rr->updateIntID) * mDNSNBBY) || bit_get_opaque64(rr->updateIntID, scopeid)) &&
5987 (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID))
5988 return mDNStrue;
5989
5990 return mDNSfalse;
5991}
5992
5993mDNSexport void UpdateRMAC(mDNS *const m, void *context)
5994{
5995 IPAddressMACMapping *addrmap = (IPAddressMACMapping *)context ;
5996 m->CurrentRecord = m->ResourceRecords;
5997
5998 if (!addrmap)
5999 {
6000 LogMsg("UpdateRMAC: Address mapping is NULL");
6001 return;
6002 }
6003
6004 while (m->CurrentRecord)
6005 {
6006 AuthRecord *rr = m->CurrentRecord;
6007 // If this is a non-sleep proxy keepalive record and the remote IP address matches, update the RData
6008 if (!rr->WakeUp.HMAC.l[0] && mDNS_KeepaliveRecord(&rr->resrec))
6009 {
6010 mDNSAddr raddr;
6011 getKeepaliveRaddr(m, rr, &raddr);
6012 if (mDNSSameAddress(&raddr, &addrmap->ipaddr))
6013 {
6014 // Update the MAC address only if it is not a zero MAC address
6015 mDNSEthAddr macAddr;
6016 mDNSu8 *ptr = GetValueForMACAddr((mDNSu8 *)(addrmap->ethaddr), (mDNSu8 *) (addrmap->ethaddr + sizeof(addrmap->ethaddr)), &macAddr);
6017 if (ptr != mDNSNULL && !mDNSEthAddressIsZero(macAddr))
6018 {
6019 UpdateKeepaliveRData(m, rr, mDNSNULL, mDNStrue, (char *)(addrmap->ethaddr));
6020 }
6021 }
6022 }
6023 m->CurrentRecord = rr->next;
6024 }
6025
6026 if (addrmap)
6027 mDNSPlatformMemFree(addrmap);
6028
6029}
6030
6031mDNSexport mStatus UpdateKeepaliveRData(mDNS *const m, AuthRecord *rr, NetworkInterfaceInfo *const intf, mDNSBool updateMac, char *ethAddr)
6032{
6033 mDNSu16 newrdlength;
6034 mDNSAddr laddr = zeroAddr;
6035 mDNSAddr raddr = zeroAddr;
6036 mDNSEthAddr eth = zeroEthAddr;
6037 mDNSIPPort lport = zeroIPPort;
6038 mDNSIPPort rport = zeroIPPort;
6039 mDNSu32 timeout = 0;
6040 mDNSu32 seq = 0;
6041 mDNSu32 ack = 0;
6042 mDNSu16 win = 0;
6043 UTF8str255 txt;
6044 int rdsize;
6045 RData *newrd;
6046 mDNSTCPInfo mti;
6047 mStatus ret;
6048
6049 // Note: If we fail to update the DNS NULL record with additional information in this function, it will be registered
6050 // with the SPS like any other record. SPS will not send keepalives if it does not have additional information.
6051 mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, &raddr, &eth, &seq, &ack, &lport, &rport, &win);
6052 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport))
6053 {
6054 LogMsg("UpdateKeepaliveRData: not a valid record %s for keepalive %#a:%d %#a:%d", ARDisplayString(m, rr), &laddr, lport.NotAnInteger, &raddr, rport.NotAnInteger);
6055 return mStatus_UnknownErr;
6056 }
6057
6058 if (updateMac)
6059 {
6060 if (laddr.type == mDNSAddrType_IPv4)
6061 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d h=%#a d=%#a l=%u r=%u m=%s", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ethAddr);
6062 else
6063 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d H=%#a D=%#a l=%u r=%u m=%s", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ethAddr);
6064
6065 }
6066 else
6067 {
6068 // If this keepalive packet would be sent on a different interface than the current one that we are processing
6069 // now, then we don't update the DNS NULL record. But we do not prevent it from registering with the SPS. When SPS sees
6070 // this DNS NULL record, it does not send any keepalives as it does not have all the information
6071 mDNSPlatformMemZero(&mti, sizeof (mDNSTCPInfo));
6072 ret = mDNSPlatformRetrieveTCPInfo(&laddr, &lport, &raddr, &rport, &mti);
6073 if (ret != mStatus_NoError)
6074 {
6075 LogMsg("mDNSPlatformRetrieveTCPInfo: mDNSPlatformRetrieveTCPInfo failed %d", ret);
6076 return ret;
6077 }
6078 if ((intf != mDNSNULL) && (mti.IntfId != intf->InterfaceID))
6079 {
6080 LogInfo("mDNSPlatformRetrieveTCPInfo: InterfaceID mismatch mti.IntfId = %p InterfaceID = %p", mti.IntfId, intf->InterfaceID);
6081 return mStatus_BadParamErr;
6082 }
6083
6084 if (laddr.type == mDNSAddrType_IPv4)
6085 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d h=%#a d=%#a l=%u r=%u m=%.6a s=%u a=%u w=%u", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), &eth, mti.seq, mti.ack, mti.window);
6086 else
6087 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d H=%#a D=%#a l=%u r=%u m=%.6a s=%u a=%u w=%u", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), &eth, mti.seq, mti.ack, mti.window);
6088 }
6089
6090 // Did we insert a null byte at the end ?
6091 if (newrdlength == (sizeof(txt.c) - 1))
6092 {
6093 LogMsg("UpdateKeepaliveRData: could not allocate memory %s", ARDisplayString(m, rr));
6094 return mStatus_NoMemoryErr;
6095 }
6096
6097 // Include the length for the null byte at the end
6098 txt.c[0] = newrdlength + 1;
6099 // Account for the first length byte and the null byte at the end
6100 newrdlength += 2;
6101
6102 rdsize = newrdlength > sizeof(RDataBody) ? newrdlength : sizeof(RDataBody);
6103 newrd = mDNSPlatformMemAllocate(sizeof(RData) - sizeof(RDataBody) + rdsize);
6104 if (!newrd) { LogMsg("UpdateKeepaliveRData: ptr NULL"); return mStatus_NoMemoryErr; }
6105
6106 newrd->MaxRDLength = (mDNSu16) rdsize;
6107 mDNSPlatformMemCopy(&newrd->u, txt.c, newrdlength);
6108
6109 // If we are updating the record for the first time, rdata points to rdatastorage as the rdata memory
6110 // was allocated as part of the AuthRecord itself. We allocate memory when we update the AuthRecord.
6111 // If the resource record has data that we allocated in a previous pass (to update MAC address),
6112 // free that memory here before copying in the new data.
6113 if ( rr->resrec.rdata != &rr->rdatastorage)
6114 {
6115 LogSPS("UpdateKeepaliveRData: Freed allocated memory for keep alive packet: %s ", ARDisplayString(m, rr));
6116 mDNSPlatformMemFree(rr->resrec.rdata);
6117 }
6118 SetNewRData(&rr->resrec, newrd, newrdlength); // Update our rdata
6119
6120 LogSPS("UpdateKeepaliveRData: successfully updated the record %s", ARDisplayString(m, rr));
6121 return mStatus_NoError;
6122}
6123
6124mDNSlocal void SendSPSRegistrationForOwner(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id, const OwnerOptData *const owner)
6125{
6126 const int optspace = DNSOpt_Header_Space + DNSOpt_LeaseData_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC);
6127 const int sps = intf->NextSPSAttempt / 3;
6128 AuthRecord *rr;
6129 mDNSOpaque16 msgid;
6130 mDNSu32 scopeid;
6131
6132 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue);
6133 if (!intf->SPSAddr[sps].type)
6134 {
6135 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond;
6136 if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0)
6137 m->NextScheduledSPRetry = intf->NextSPSAttemptTime;
6138 LogSPS("SendSPSRegistration: %s SPS %d (%d) %##s not yet resolved", intf->ifname, intf->NextSPSAttempt, sps, intf->NetWakeResolve[sps].qname.c);
6139 goto exit;
6140 }
6141
6142 // Mark our mDNS records (not unicast records) for transfer to SPS
6143 if (mDNSOpaque16IsZero(id))
6144 {
6145 // We may have to register this record over multiple interfaces and we don't want to
6146 // overwrite the id. We send the registration over interface X with id "IDX" and before
6147 // we get a response, we overwrite with id "IDY" for interface Y and we won't accept responses
6148 // for "IDX". Hence, we want to use the same ID across all interfaces.
6149 //
6150 // In the case of sleep proxy server transfering its records when it goes to sleep, the owner
6151 // option check below will set the same ID across the records from the same owner. Records
6152 // with different owner option gets different ID.
6153 msgid = mDNS_NewMessageID(m);
6154 for (rr = m->ResourceRecords; rr; rr=rr->next)
6155 {
6156 if (!(rr->AuthFlags & AuthFlagsWakeOnly) && rr->resrec.RecordType > kDNSRecordTypeDeregistering)
6157 {
6158 if (rr->resrec.InterfaceID == intf->InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name))))
6159 {
6160 if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner)))
6161 {
6162 rr->SendRNow = mDNSInterfaceMark; // mark it now
6163 // When we are registering on the first interface, rr->updateid is zero in which case
6164 // initialize with the new ID. For subsequent interfaces, we want to use the same ID.
6165 // At the end, all the updates sent across all the interfaces with the same ID.
6166 if (mDNSOpaque16IsZero(rr->updateid))
6167 rr->updateid = msgid;
6168 else
6169 msgid = rr->updateid;
6170 }
6171 }
6172 }
6173 }
6174 }
6175 else
6176 msgid = id;
6177
6178 while (1)
6179 {
6180 mDNSu8 *p = m->omsg.data;
6181 // To comply with RFC 2782, PutResourceRecord suppresses name compression for SRV records in unicast updates.
6182 // For now we follow that same logic for SPS registrations too.
6183 // If we decide to compress SRV records in SPS registrations in the future, we can achieve that by creating our
6184 // initial DNSMessage with h.flags set to zero, and then update it to UpdateReqFlags right before sending the packet.
6185 InitializeDNSMessage(&m->omsg.h, msgid, UpdateReqFlags);
6186
6187 for (rr = m->ResourceRecords; rr; rr=rr->next)
6188 if (rr->SendRNow || mDNSUpdateOkToSend(m, rr, intf, scopeid))
6189 {
6190 if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner)))
6191 {
6192 mDNSu8 *newptr;
6193 const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.mDNS_numUpdates ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData) - optspace;
6194
6195 // If we can't update the keepalive record, don't send it
6196 if (mDNS_KeepaliveRecord(&rr->resrec) && (UpdateKeepaliveRData(m, rr, intf, mDNSfalse, mDNSNULL) != mStatus_NoError))
6197 {
6198 if (scopeid < (sizeof(rr->updateIntID) * mDNSNBBY))
6199 {
6200 bit_clr_opaque64(rr->updateIntID, scopeid);
6201 }
6202 rr->SendRNow = mDNSNULL;
6203 continue;
6204 }
6205
6206 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
6207 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the 'unique' bit so PutResourceRecord will set it
6208 newptr = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit);
6209 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear 'unique' bit back to normal state
6210 if (!newptr)
6211 LogSPS("SendSPSRegistration put %s FAILED %d/%d %s", intf->ifname, p - m->omsg.data, limit - m->omsg.data, ARDisplayString(m, rr));
6212 else
6213 {
6214 LogSPS("SendSPSRegistration put %s 0x%x 0x%x (updateid %d) %s", intf->ifname, rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(m->omsg.h.id), ARDisplayString(m, rr));
6215 rr->SendRNow = mDNSNULL;
6216 rr->ThisAPInterval = mDNSPlatformOneSecond;
6217 rr->LastAPTime = m->timenow;
6218 // should be initialized above
6219 if (mDNSOpaque16IsZero(rr->updateid)) LogMsg("SendSPSRegistration: ERROR!! rr %s updateid is zero", ARDisplayString(m, rr));
6220 if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
6221 m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval);
6222 p = newptr;
6223 }
6224 }
6225 }
6226
6227 if (!m->omsg.h.mDNS_numUpdates) break;
6228 else
6229 {
6230 AuthRecord opt;
6231 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
6232 opt.resrec.rrclass = NormalMaxDNSMessageData;
6233 opt.resrec.rdlength = sizeof(rdataOPT) * 2; // Two options in this OPT record
6234 opt.resrec.rdestimate = sizeof(rdataOPT) * 2;
6235 opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease;
6236 opt.resrec.rdata->u.opt[0].optlen = DNSOpt_LeaseData_Space - 4;
6237 opt.resrec.rdata->u.opt[0].u.updatelease = DEFAULT_UPDATE_LEASE;
6238 if (!owner->HMAC.l[0]) // If no owner data,
6239 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[1]); // use our own interface information
6240 else // otherwise, use the owner data we were given
6241 {
6242 opt.resrec.rdata->u.opt[1].u.owner = *owner;
6243 opt.resrec.rdata->u.opt[1].opt = kDNSOpt_Owner;
6244 opt.resrec.rdata->u.opt[1].optlen = DNSOpt_Owner_Space(&owner->HMAC, &owner->IMAC) - 4;
6245 }
6246 LogSPS("SendSPSRegistration put %s %s", intf->ifname, ARDisplayString(m, &opt));
6247 p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData);
6248 if (!p)
6249 LogMsg("SendSPSRegistration: Failed to put OPT record (%d updates) %s", m->omsg.h.mDNS_numUpdates, ARDisplayString(m, &opt));
6250 else
6251 {
6252 mStatus err;
6253
6254 LogSPS("SendSPSRegistration: Sending Update %s %d (%d) id %5d with %d records %d bytes to %#a:%d", intf->ifname, intf->NextSPSAttempt, sps,
6255 mDNSVal16(m->omsg.h.id), m->omsg.h.mDNS_numUpdates, p - m->omsg.data, &intf->SPSAddr[sps], mDNSVal16(intf->SPSPort[sps]));
6256 // if (intf->NextSPSAttempt < 5) m->omsg.h.flags = zeroID; // For simulating packet loss
6257 err = mDNSSendDNSMessage(m, &m->omsg, p, intf->InterfaceID, mDNSNULL, &intf->SPSAddr[sps], intf->SPSPort[sps], mDNSNULL, mDNSNULL, mDNSfalse);
6258 if (err) LogSPS("SendSPSRegistration: mDNSSendDNSMessage err %d", err);
6259 if (err && intf->SPSAddr[sps].type == mDNSAddrType_IPv4 && intf->NetWakeResolve[sps].ThisQInterval == -1)
6260 {
6261 LogSPS("SendSPSRegistration %d %##s failed to send to IPv4 address; will try IPv6 instead", sps, intf->NetWakeResolve[sps].qname.c);
6262 intf->NetWakeResolve[sps].qtype = kDNSType_AAAA;
6263 mDNS_StartQuery_internal(m, &intf->NetWakeResolve[sps]);
6264 return;
6265 }
6266 }
6267 }
6268 }
6269
6270 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond * 10; // If successful, update NextSPSAttemptTime
6271
6272exit:
6273 if (mDNSOpaque16IsZero(id) && intf->NextSPSAttempt < 8) intf->NextSPSAttempt++;
6274}
6275
6276mDNSlocal mDNSBool RecordIsFirstOccurrenceOfOwner(mDNS *const m, const AuthRecord *const rr)
6277{
6278 AuthRecord *ar;
6279 for (ar = m->ResourceRecords; ar && ar != rr; ar=ar->next)
6280 if (mDNSPlatformMemSame(&rr->WakeUp, &ar->WakeUp, sizeof(rr->WakeUp))) return mDNSfalse;
6281 return mDNStrue;
6282}
6283
6284mDNSlocal void mDNSCoreStoreProxyRR(mDNS *const m, const mDNSInterfaceID InterfaceID, AuthRecord *const rr)
6285{
6286 AuthRecord *newRR = mDNSPlatformMemAllocate(sizeof(AuthRecord));
6287
6288 if (newRR == mDNSNULL)
6289 {
6290 LogSPS("%s : could not allocate memory for new resource record", __func__);
6291 return;
6292 }
6293
6294 mDNSPlatformMemZero(newRR, sizeof(AuthRecord));
6295 mDNS_SetupResourceRecord(newRR, mDNSNULL, InterfaceID, rr->resrec.rrtype,
6296 rr->resrec.rroriginalttl, rr->resrec.RecordType,
6297 rr->ARType, mDNSNULL, mDNSNULL);
6298
6299 AssignDomainName(&newRR->namestorage, &rr->namestorage);
6300 newRR->resrec.rdlength = DomainNameLength(rr->resrec.name);
6301 newRR->resrec.namehash = DomainNameHashValue(newRR->resrec.name);
6302 newRR->resrec.rrclass = rr->resrec.rrclass;
6303
6304 if (rr->resrec.rrtype == kDNSType_A)
6305 {
6306 newRR->resrec.rdata->u.ipv4 = rr->resrec.rdata->u.ipv4;
6307 }
6308 else if (rr->resrec.rrtype == kDNSType_AAAA)
6309 {
6310 newRR->resrec.rdata->u.ipv6 = rr->resrec.rdata->u.ipv6;
6311 }
6312 SetNewRData(&newRR->resrec, mDNSNULL, 0);
6313
6314 // Insert the new node at the head of the list.
6315 newRR->next = m->SPSRRSet;
6316 m->SPSRRSet = newRR;
6317 LogSPS("%s : Storing proxy record : %s ", __func__, ARDisplayString(m, rr));
6318}
6319
6320// Some records are interface specific and some are not. The ones that are supposed to be registered
6321// on multiple interfaces need to be initialized with all the valid interfaces on which it will be sent.
6322// updateIntID bit field tells us on which interfaces we need to register this record. When we get an
6323// ack from the sleep proxy server, we clear the interface bit. This way, we know when a record completes
6324// registration on all the interfaces
6325mDNSlocal void SPSInitRecordsBeforeUpdate(mDNS *const m, mDNSOpaque64 updateIntID, mDNSBool *WakeOnlyService)
6326{
6327 AuthRecord *ar;
6328 LogSPS("SPSInitRecordsBeforeUpdate: UpdateIntID 0x%x 0x%x", updateIntID.l[1], updateIntID.l[0]);
6329
6330 *WakeOnlyService = mDNSfalse;
6331
6332 // Before we store the A and AAAA records that we are going to register with the sleep proxy,
6333 // make sure that the old sleep proxy records are removed.
6334 mDNSCoreFreeProxyRR(m);
6335
6336 // For records that are registered only on a specific interface, mark only that bit as it will
6337 // never be registered on any other interface. For others, it should be sent on all interfaces.
6338 for (ar = m->ResourceRecords; ar; ar=ar->next)
6339 {
6340 ar->updateIntID = zeroOpaque64;
6341 ar->updateid = zeroID;
6342 if (AuthRecord_uDNS(ar))
6343 {
6344 continue;
6345 }
6346 if (ar->AuthFlags & AuthFlagsWakeOnly)
6347 {
6348 if (ar->resrec.RecordType == kDNSRecordTypeShared && ar->RequireGoodbye)
6349 {
6350 ar->ImmedAnswer = mDNSInterfaceMark;
6351 *WakeOnlyService = mDNStrue;
6352 continue;
6353 }
6354 }
6355 if (!ar->resrec.InterfaceID)
6356 {
6357 LogSPS("Setting scopeid (ALL) 0x%x 0x%x for %s", updateIntID.l[1], updateIntID.l[0], ARDisplayString(m, ar));
6358 ar->updateIntID = updateIntID;
6359 }
6360 else
6361 {
6362 // Filter records that belong to interfaces that we won't register the records on. UpdateIntID captures
6363 // exactly this.
6364 mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, ar->resrec.InterfaceID, mDNStrue);
6365 if ((scopeid < (sizeof(updateIntID) * mDNSNBBY)) && bit_get_opaque64(updateIntID, scopeid))
6366 {
6367 bit_set_opaque64(ar->updateIntID, scopeid);
6368 LogSPS("SPSInitRecordsBeforeUpdate: Setting scopeid(%d) 0x%x 0x%x for %s", scopeid, ar->updateIntID.l[1],
6369 ar->updateIntID.l[0], ARDisplayString(m, ar));
6370 }
6371 else
6372 {
6373 LogSPS("SPSInitRecordsBeforeUpdate: scopeid %d beyond range or not valid for SPS registration", scopeid);
6374 }
6375 }
6376 // Store the A and AAAA records that we registered with the sleep proxy.
6377 // We will use this to prevent spurious name conflicts that may occur when we wake up
6378 if (ar->resrec.rrtype == kDNSType_A || ar->resrec.rrtype == kDNSType_AAAA)
6379 {
6380 mDNSCoreStoreProxyRR(m, ar->resrec.InterfaceID, ar);
6381 }
6382 }
6383}
6384
6385mDNSlocal void SendSPSRegistration(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id)
6386{
6387 AuthRecord *ar;
6388 OwnerOptData owner = zeroOwner;
6389
6390 SendSPSRegistrationForOwner(m, intf, id, &owner);
6391
6392 for (ar = m->ResourceRecords; ar; ar=ar->next)
6393 {
6394 if (!mDNSPlatformMemSame(&owner, &ar->WakeUp, sizeof(owner)) && RecordIsFirstOccurrenceOfOwner(m, ar))
6395 {
6396 owner = ar->WakeUp;
6397 SendSPSRegistrationForOwner(m, intf, id, &owner);
6398 }
6399 }
6400}
6401
6402// RetrySPSRegistrations is called from SendResponses, with the lock held
6403mDNSlocal void RetrySPSRegistrations(mDNS *const m)
6404{
6405 AuthRecord *rr;
6406 NetworkInterfaceInfo *intf;
6407
6408 // First make sure none of our interfaces' NextSPSAttemptTimes are inadvertently set to m->timenow + mDNSPlatformOneSecond * 10
6409 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
6410 if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10)
6411 intf->NextSPSAttemptTime++;
6412
6413 // Retry any record registrations that are due
6414 for (rr = m->ResourceRecords; rr; rr=rr->next)
6415 if (!AuthRecord_uDNS(rr) && !mDNSOpaque16IsZero(rr->updateid) && m->timenow - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
6416 {
6417 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
6418 {
6419 // If we still have registrations pending on this interface, send it now
6420 mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue);
6421 if ((scopeid >= (sizeof(rr->updateIntID) * mDNSNBBY) || bit_get_opaque64(rr->updateIntID, scopeid)) &&
6422 (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID))
6423 {
6424 LogSPS("RetrySPSRegistrations: 0x%x 0x%x (updateid %d) %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m, rr));
6425 SendSPSRegistration(m, intf, rr->updateid);
6426 }
6427 }
6428 }
6429
6430 // For interfaces where we did an SPS registration attempt, increment intf->NextSPSAttempt
6431 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
6432 if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10 && intf->NextSPSAttempt < 8)
6433 intf->NextSPSAttempt++;
6434}
6435
6436mDNSlocal void NetWakeResolve(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
6437{
6438 NetworkInterfaceInfo *intf = (NetworkInterfaceInfo *)question->QuestionContext;
6439 int sps = (int)(question - intf->NetWakeResolve);
6440 (void)m; // Unused
6441 LogSPS("NetWakeResolve: SPS: %d Add: %d %s", sps, AddRecord, RRDisplayString(m, answer));
6442
6443 if (!AddRecord) return; // Don't care about REMOVE events
6444 if (answer->rrtype != question->qtype) return; // Don't care about CNAMEs
6445
6446 // if (answer->rrtype == kDNSType_AAAA && sps == 0) return; // To test failing to resolve sleep proxy's address
6447
6448 if (answer->rrtype == kDNSType_SRV)
6449 {
6450 // 1. Got the SRV record; now look up the target host's IP address
6451 mDNS_StopQuery(m, question);
6452 intf->SPSPort[sps] = answer->rdata->u.srv.port;
6453 AssignDomainName(&question->qname, &answer->rdata->u.srv.target);
6454 question->qtype = kDNSType_A;
6455 mDNS_StartQuery(m, question);
6456 }
6457 else if (answer->rrtype == kDNSType_A && answer->rdlength == sizeof(mDNSv4Addr))
6458 {
6459 // 2. Got an IPv4 address for the target host; record address and initiate an SPS registration if appropriate
6460 mDNS_StopQuery(m, question);
6461 question->ThisQInterval = -1;
6462 intf->SPSAddr[sps].type = mDNSAddrType_IPv4;
6463 intf->SPSAddr[sps].ip.v4 = answer->rdata->u.ipv4;
6464 mDNS_Lock(m);
6465 if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now
6466 mDNS_Unlock(m);
6467 }
6468 else if (answer->rrtype == kDNSType_A && answer->rdlength == 0)
6469 {
6470 // 3. Got negative response -- target host apparently has IPv6 disabled -- so try looking up the target host's IPv4 address(es) instead
6471 mDNS_StopQuery(m, question);
6472 LogSPS("NetWakeResolve: SPS %d %##s has no IPv4 address, will try IPv6 instead", sps, question->qname.c);
6473 question->qtype = kDNSType_AAAA;
6474 mDNS_StartQuery(m, question);
6475 }
6476 else if (answer->rrtype == kDNSType_AAAA && answer->rdlength == sizeof(mDNSv6Addr) && mDNSv6AddressIsLinkLocal(&answer->rdata->u.ipv6))
6477 {
6478 // 4. Got the target host's IPv6 link-local address; record address and initiate an SPS registration if appropriate
6479 mDNS_StopQuery(m, question);
6480 question->ThisQInterval = -1;
6481 intf->SPSAddr[sps].type = mDNSAddrType_IPv6;
6482 intf->SPSAddr[sps].ip.v6 = answer->rdata->u.ipv6;
6483 mDNS_Lock(m);
6484 if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now
6485 mDNS_Unlock(m);
6486 }
6487}
6488
6489mDNSexport mDNSBool mDNSCoreHaveAdvertisedMulticastServices(mDNS *const m)
6490{
6491 AuthRecord *rr;
6492 for (rr = m->ResourceRecords; rr; rr=rr->next)
6493 if (mDNS_KeepaliveRecord(&rr->resrec) || (rr->resrec.rrtype == kDNSType_SRV && !AuthRecord_uDNS(rr) && !mDNSSameIPPort(rr->resrec.rdata->u.srv.port, DiscardPort)))
6494 return mDNStrue;
6495 return mDNSfalse;
6496}
6497
6498#define WAKE_ONLY_SERVICE 1
6499#define AC_ONLY_SERVICE 2
6500
6501#ifdef APPLE_OSX_mDNSResponder
6502mDNSlocal void SendGoodbyesForSelectServices(mDNS *const m, mDNSBool *servicePresent, mDNSu32 serviceType)
6503{
6504 AuthRecord *rr;
6505 *servicePresent = mDNSfalse;
6506
6507 // Mark all the records we need to deregister and send them
6508 for (rr = m->ResourceRecords; rr; rr=rr->next)
6509 {
6510 // If the service type is wake only service and the auth flags match and requires a goodbye
6511 // OR if the service type is AC only and it is not a keepalive record,
6512 // mark the records we need to deregister and send them
6513 if ((serviceType == WAKE_ONLY_SERVICE && (rr->AuthFlags & AuthFlagsWakeOnly) &&
6514 rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) ||
6515 (serviceType == AC_ONLY_SERVICE && !mDNS_KeepaliveRecord(&rr->resrec)))
6516 {
6517 rr->ImmedAnswer = mDNSInterfaceMark;
6518 *servicePresent = mDNStrue;
6519 }
6520 }
6521}
6522#endif
6523
6524#ifdef APPLE_OSX_mDNSResponder
6525// This function is used only in the case of local NIC proxy. For external
6526// sleep proxy server, we do this in SPSInitRecordsBeforeUpdate when we
6527// walk the resource records.
6528mDNSlocal void SendGoodbyesForWakeOnlyService(mDNS *const m, mDNSBool *WakeOnlyService)
6529{
6530 return SendGoodbyesForSelectServices(m, WakeOnlyService, WAKE_ONLY_SERVICE);
6531}
6532#endif // APPLE_OSX_mDNSResponder
6533
6534
6535mDNSlocal void SendSleepGoodbyes(mDNS *const m, mDNSBool AllInterfaces, mDNSBool unicast)
6536{
6537 AuthRecord *rr;
6538 m->SleepState = SleepState_Sleeping;
6539
6540 // If AllInterfaces is not set, the caller has already marked it appropriately
6541 // on which interfaces this should be sent.
6542 if (AllInterfaces)
6543 {
6544 NetworkInterfaceInfo *intf;
6545 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
6546 {
6547 intf->SendGoodbyes = 1;
6548 }
6549 }
6550 if (unicast)
6551 {
6552#ifndef UNICAST_DISABLED
6553 SleepRecordRegistrations(m); // If we have no SPS, need to deregister our uDNS records
6554#endif /* UNICAST_DISABLED */
6555 }
6556
6557 // Mark all the records we need to deregister and send them
6558 for (rr = m->ResourceRecords; rr; rr=rr->next)
6559 if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye)
6560 rr->ImmedAnswer = mDNSInterfaceMark;
6561 SendResponses(m);
6562}
6563
6564/*
6565 * This function attempts to detect if multiple interfaces are on the same subnet.
6566 * It makes this determination based only on the IPv4 Addresses and subnet masks.
6567 * IPv6 link local addresses that are configured by default on all interfaces make
6568 * it hard to make this determination
6569 *
6570 * The 'real' fix for this would be to send out multicast packets over one interface
6571 * and conclude that multiple interfaces are on the same subnet only if these packets
6572 * are seen on other interfaces on the same system
6573 */
6574mDNSlocal mDNSBool skipSameSubnetRegistration(mDNS *const m, mDNSInterfaceID *regID, mDNSu32 count, mDNSInterfaceID intfid)
6575{
6576 NetworkInterfaceInfo *intf;
6577 NetworkInterfaceInfo *newIntf;
6578 mDNSu32 i;
6579
6580 for (newIntf = FirstInterfaceForID(m, intfid); newIntf; newIntf = newIntf->next)
6581 {
6582 if ((newIntf->InterfaceID != intfid) ||
6583 (newIntf->ip.type != mDNSAddrType_IPv4))
6584 {
6585 continue;
6586 }
6587 for ( i = 0; i < count; i++)
6588 {
6589 for (intf = FirstInterfaceForID(m, regID[i]); intf; intf = intf->next)
6590 {
6591 if ((intf->InterfaceID != regID[i]) ||
6592 (intf->ip.type != mDNSAddrType_IPv4))
6593 {
6594 continue;
6595 }
6596 if ((intf->ip.ip.v4.NotAnInteger & intf->mask.ip.v4.NotAnInteger) == (newIntf->ip.ip.v4.NotAnInteger & newIntf->mask.ip.v4.NotAnInteger))
6597 {
6598 LogSPS("%s : Already registered for the same subnet (IPv4) for interface %s", __func__, intf->ifname);
6599 return (mDNStrue);
6600 }
6601 }
6602 }
6603 }
6604 return (mDNSfalse);
6605}
6606
6607mDNSlocal void DoKeepaliveCallbacks(mDNS *m)
6608{
6609 // Loop through the keepalive records and callback with an error
6610 m->CurrentRecord = m->ResourceRecords;
6611 while (m->CurrentRecord)
6612 {
6613 AuthRecord *const rr = m->CurrentRecord;
6614 if ((mDNS_KeepaliveRecord(&rr->resrec)) && (rr->resrec.RecordType != kDNSRecordTypeDeregistering))
6615 {
6616 LogSPS("DoKeepaliveCallbacks: Invoking the callback for %s", ARDisplayString(m, rr));
6617 if (rr->RecordCallback)
6618 rr->RecordCallback(m, rr, mStatus_BadStateErr);
6619 }
6620 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
6621 m->CurrentRecord = rr->next;
6622 }
6623}
6624
6625// BeginSleepProcessing is called, with the lock held, from either mDNS_Execute or mDNSCoreMachineSleep
6626mDNSlocal void BeginSleepProcessing(mDNS *const m)
6627{
6628 mDNSBool SendGoodbyes = mDNStrue;
6629 mDNSBool WakeOnlyService = mDNSfalse;
6630 mDNSBool invokeKACallback = mDNStrue;
6631 const CacheRecord *sps[3] = { mDNSNULL };
6632 mDNSOpaque64 updateIntID = zeroOpaque64;
6633 mDNSInterfaceID registeredIntfIDS[128] = { 0 };
6634 mDNSu32 registeredCount = 0;
6635 int skippedRegistrations = 0;
6636
6637 m->NextScheduledSPRetry = m->timenow;
6638
6639 // Clear out the SCDynamic entry that stores the external SPS information
6640 mDNSPlatformClearSPSData();
6641
6642 if (!m->SystemWakeOnLANEnabled) LogSPS("BeginSleepProcessing: m->SystemWakeOnLANEnabled is false");
6643 else if (!mDNSCoreHaveAdvertisedMulticastServices(m)) LogSPS("BeginSleepProcessing: No advertised services");
6644 else // If we have at least one advertised service
6645 {
6646 NetworkInterfaceInfo *intf;
6647 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
6648 {
6649 // Intialize it to false. These values make sense only when SleepState is set to Sleeping.
6650 intf->SendGoodbyes = 0;
6651
6652 // If it is not multicast capable, we could not have possibly discovered sleep proxy
6653 // servers.
6654 if (!intf->McastTxRx || mDNSPlatformInterfaceIsD2D(intf->InterfaceID))
6655 {
6656 LogSPS("BeginSleepProcessing: %-6s Ignoring for registrations", intf->ifname);
6657 continue;
6658 }
6659
6660 // If we are not capable of WOMP, then don't register with sleep proxy.
6661 //
6662 // Note: If we are not NetWake capable, we don't browse for the sleep proxy server.
6663 // We might find sleep proxy servers in the cache and start a resolve on them.
6664 // But then if the interface goes away, we won't stop these questions because
6665 // mDNS_DeactivateNetWake_internal assumes that a browse has been started for it
6666 // to stop both the browse and resolve questions.
6667 if (!intf->NetWake)
6668 {
6669 LogSPS("BeginSleepProcessing: %-6s not capable of magic packet wakeup", intf->ifname);
6670 intf->SendGoodbyes = 1;
6671 skippedRegistrations++;
6672 continue;
6673 }
6674
6675 // Check if we have already registered with a sleep proxy for this subnet
6676 if (skipSameSubnetRegistration(m, registeredIntfIDS, registeredCount, intf->InterfaceID))
6677 {
6678 LogSPS("%s : Skipping sleep proxy registration on %s", __func__, intf->ifname);
6679 continue;
6680 }
6681
6682#if APPLE_OSX_mDNSResponder
6683 else if (SupportsInNICProxy(intf))
6684 {
6685 mDNSBool keepaliveOnly = mDNSfalse;
6686 if (ActivateLocalProxy(intf, &keepaliveOnly) == mStatus_NoError)
6687 {
6688 SendGoodbyesForWakeOnlyService(m, &WakeOnlyService);
6689
6690 // Send goodbyes for all advertised services if the only record offloaded was the keepalive record.
6691 SendGoodbyes = (keepaliveOnly) ? mDNStrue: mDNSfalse;
6692 invokeKACallback = mDNSfalse;
6693 LogSPS("BeginSleepProcessing: %-6s using local proxy", intf->ifname);
6694 // This will leave m->SleepState set to SleepState_Transferring,
6695 // which is okay because with no outstanding resolves, or updates in flight,
6696 // mDNSCoreReadyForSleep() will conclude correctly that all the updates have already completed
6697
6698 // Setting this flag activates the SleepLimit which delays sleep by 5 seconds and
6699 // will allow the system to deregister any BTMM records.
6700 m->NextScheduledSPRetry = m->timenow + (5 * mDNSPlatformOneSecond);
6701 registeredIntfIDS[registeredCount] = intf->InterfaceID;
6702 registeredCount++;
6703 }
6704 }
6705#endif // APPLE_OSX_mDNSResponder
6706 else
6707 {
6708#if APPLE_OSX_mDNSResponder
6709 // If on battery, do not attempt to offload to external sleep proxies
6710 if (m->SystemWakeOnLANEnabled == mDNS_WakeOnBattery)
6711 {
6712 LogSPS("BegingSleepProcessing: Not connected to AC power - Not registering with an external sleep proxy.");
6713 return;
6714 }
6715#endif // APPLE_OSX_mDNSResponder
6716 FindSPSInCache(m, &intf->NetWakeBrowse, sps);
6717 if (!sps[0]) LogSPS("BeginSleepProcessing: %-6s %#a No Sleep Proxy Server found (Next Browse Q in %d, interval %d)",
6718 intf->ifname, &intf->ip, NextQSendTime(&intf->NetWakeBrowse) - m->timenow, intf->NetWakeBrowse.ThisQInterval);
6719 else
6720 {
6721 int i;
6722 mDNSu32 scopeid;
6723 SendGoodbyes = mDNSfalse;
6724 intf->NextSPSAttempt = 0;
6725 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond;
6726
6727 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue);
6728 // Now we know for sure that we have to wait for registration to complete on this interface.
6729 if (scopeid < (sizeof(updateIntID) * mDNSNBBY))
6730 bit_set_opaque64(updateIntID, scopeid);
6731
6732 // Don't need to set m->NextScheduledSPRetry here because we already set "m->NextScheduledSPRetry = m->timenow" above
6733 for (i=0; i<3; i++)
6734 {
6735#if ForceAlerts
6736 if (intf->SPSAddr[i].type)
6737 LogFatalError("BeginSleepProcessing: %s %d intf->SPSAddr[i].type %d", intf->ifname, i, intf->SPSAddr[i].type);
6738 if (intf->NetWakeResolve[i].ThisQInterval >= 0)
6739 LogFatalError("BeginSleepProcessing: %s %d intf->NetWakeResolve[i].ThisQInterval %d", intf->ifname, i, intf->NetWakeResolve[i].ThisQInterval);
6740#endif
6741 intf->SPSAddr[i].type = mDNSAddrType_None;
6742 if (intf->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery(m, &intf->NetWakeResolve[i]);
6743 intf->NetWakeResolve[i].ThisQInterval = -1;
6744 if (sps[i])
6745 {
6746 LogSPS("BeginSleepProcessing: %-6s Found Sleep Proxy Server %d TTL %d %s", intf->ifname, i, sps[i]->resrec.rroriginalttl, CRDisplayString(m, sps[i]));
6747 mDNS_SetupQuestion(&intf->NetWakeResolve[i], intf->InterfaceID, &sps[i]->resrec.rdata->u.name, kDNSType_SRV, NetWakeResolve, intf);
6748 intf->NetWakeResolve[i].ReturnIntermed = mDNStrue;
6749 mDNS_StartQuery_internal(m, &intf->NetWakeResolve[i]);
6750
6751 // If we are registering with a Sleep Proxy for a new subnet, add it to our list
6752 registeredIntfIDS[registeredCount] = intf->InterfaceID;
6753 registeredCount++;
6754 }
6755 }
6756 }
6757 }
6758 }
6759 }
6760
6761 // If we have at least one interface on which we are registering with an external sleep proxy,
6762 // initialize all the records appropriately.
6763 if (!mDNSOpaque64IsZero(&updateIntID))
6764 SPSInitRecordsBeforeUpdate(m, updateIntID, &WakeOnlyService);
6765
6766 // Call the applicaitons that registered a keepalive record to inform them that we failed to offload
6767 // the records to a sleep proxy.
6768 if (invokeKACallback)
6769 {
6770 LogSPS("BeginSleepProcessing: Did not register with an in-NIC proxy - invoking the callbacks for KA records");
6771 DoKeepaliveCallbacks(m);
6772 }
6773
6774 // SendSleepGoodbyes last two arguments control whether we send goodbyes on all
6775 // interfaces and also deregister unicast registrations.
6776 //
6777 // - If there are no sleep proxy servers, then send goodbyes on all interfaces
6778 // for both multicast and unicast.
6779 //
6780 // - If we skipped registrations on some interfaces, then we have already marked
6781 // them appropriately above. We don't need to send goodbyes for unicast as
6782 // we have registered with at least one sleep proxy.
6783 //
6784 // - If we are not planning to send any goodbyes, then check for WakeOnlyServices.
6785 //
6786 // Note: If we are planning to send goodbyes, we mark the record with mDNSInterfaceAny
6787 // and call SendResponses which inturn calls ShouldSendGoodbyesBeforeSleep which looks
6788 // at WakeOnlyServices first.
6789 if (SendGoodbyes)
6790 {
6791 LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server");
6792 SendSleepGoodbyes(m, mDNStrue, mDNStrue);
6793 }
6794 else if (skippedRegistrations)
6795 {
6796 LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server on all interfaces");
6797 SendSleepGoodbyes(m, mDNSfalse, mDNSfalse);
6798 }
6799 else if (WakeOnlyService)
6800 {
6801 // If we saw WakeOnly service above, send the goodbyes now.
6802 LogSPS("BeginSleepProcessing: Sending goodbyes for WakeOnlyService");
6803 SendResponses(m);
6804 }
6805}
6806
6807// Call mDNSCoreMachineSleep(m, mDNStrue) when the machine is about to go to sleep.
6808// Call mDNSCoreMachineSleep(m, mDNSfalse) when the machine is has just woken up.
6809// Normally, the platform support layer below mDNSCore should call this, not the client layer above.
6810mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleep)
6811{
6812 AuthRecord *rr;
6813
6814 LogSPS("%s (old state %d) at %ld", sleep ? "Sleeping" : "Waking", m->SleepState, m->timenow);
6815
6816 if (sleep && !m->SleepState) // Going to sleep
6817 {
6818 mDNS_Lock(m);
6819 // If we're going to sleep, need to stop advertising that we're a Sleep Proxy Server
6820 if (m->SPSSocket)
6821 {
6822 mDNSu8 oldstate = m->SPSState;
6823 mDNS_DropLockBeforeCallback(); // mDNS_DeregisterService expects to be called without the lock held, so we emulate that here
6824 m->SPSState = 2;
6825#ifndef SPC_DISABLED
6826 if (oldstate == 1) mDNS_DeregisterService(m, &m->SPSRecords);
6827#else
6828 (void)oldstate;
6829#endif
6830 mDNS_ReclaimLockAfterCallback();
6831 }
6832
6833 m->SleepState = SleepState_Transferring;
6834 if (m->SystemWakeOnLANEnabled && m->DelaySleep)
6835 {
6836 // If we just woke up moments ago, allow ten seconds for networking to stabilize before going back to sleep
6837 LogSPS("mDNSCoreMachineSleep: Re-sleeping immediately after waking; will delay for %d ticks", m->DelaySleep - m->timenow);
6838 m->SleepLimit = NonZeroTime(m->DelaySleep + mDNSPlatformOneSecond * 10);
6839 }
6840 else
6841 {
6842 m->DelaySleep = 0;
6843 m->SleepLimit = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 10);
6844 m->mDNSStats.Sleeps++;
6845 BeginSleepProcessing(m);
6846 }
6847
6848#ifndef UNICAST_DISABLED
6849 SuspendLLQs(m);
6850#endif
6851#if APPLE_OSX_mDNSResponder
6852 RemoveAutoTunnel6Record(m);
6853#endif
6854 LogSPS("mDNSCoreMachineSleep: m->SleepState %d (%s) seq %d", m->SleepState,
6855 m->SleepState == SleepState_Transferring ? "Transferring" :
6856 m->SleepState == SleepState_Sleeping ? "Sleeping" : "?", m->SleepSeqNum);
6857 mDNS_Unlock(m);
6858 }
6859 else if (!sleep) // Waking up
6860 {
6861 mDNSu32 slot;
6862 CacheGroup *cg;
6863 CacheRecord *cr;
6864 NetworkInterfaceInfo *intf;
6865 mDNSs32 currtime, diff;
6866
6867 mDNS_Lock(m);
6868 // Reset SleepLimit back to 0 now that we're awake again.
6869 m->SleepLimit = 0;
6870
6871 // If we were previously sleeping, but now we're not, increment m->SleepSeqNum to indicate that we're entering a new period of wakefulness
6872 if (m->SleepState != SleepState_Awake)
6873 {
6874 m->SleepState = SleepState_Awake;
6875 m->SleepSeqNum++;
6876 // If the machine wakes and then immediately tries to sleep again (e.g. a maintenance wake)
6877 // then we enforce a minimum delay of five seconds before we begin sleep processing.
6878 // This is to allow time for the Ethernet link to come up, DHCP to get an address, mDNS to issue queries, etc.,
6879 // before we make our determination of whether there's a Sleep Proxy out there we should register with.
6880 m->DelaySleep = NonZeroTime(m->timenow + kDarkWakeDelaySleep);
6881 }
6882
6883 if (m->SPSState == 3)
6884 {
6885 m->SPSState = 0;
6886 mDNSCoreBeSleepProxyServer_internal(m, m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower, m->SPSFeatureFlags);
6887 }
6888 m->mDNSStats.Wakes++;
6889 m->DelayConflictProcessing = MAX_CONFLICT_PROCESSING_DELAYS;
6890 // ... and the same for NextSPSAttempt
6891 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) intf->NextSPSAttempt = -1;
6892
6893 // Restart unicast and multicast queries
6894 mDNSCoreRestartQueries(m);
6895
6896 // and reactivtate service registrations
6897 m->NextSRVUpdate = NonZeroTime(m->timenow + mDNSPlatformOneSecond);
6898 LogInfo("mDNSCoreMachineSleep waking: NextSRVUpdate in %d %d", m->NextSRVUpdate - m->timenow, m->timenow);
6899
6900 // 2. Re-validate our cache records
6901 currtime = mDNSPlatformUTC();
6902
6903 diff = currtime - m->TimeSlept;
6904 FORALL_CACHERECORDS(slot, cg, cr)
6905 {
6906 // Temporary fix: For unicast cache records, look at how much time we slept.
6907 // Adjust the RecvTime by the amount of time we slept so that we age the
6908 // cache record appropriately. If it is expired already, purge. If there
6909 // is a network change that happens after the wakeup, we might purge the
6910 // cache anyways and this helps only in the case where there are no network
6911 // changes across sleep/wakeup transition.
6912 //
6913 // Note: If there is a network/DNS server change that already happened and
6914 // these cache entries are already refreshed and we are getting a delayed
6915 // wake up notification, we might adjust the TimeRcvd based on the time slept
6916 // now which can cause the cache to purge pre-maturely. As this is not a very
6917 // common case, this should happen rarely.
6918 if (!cr->resrec.InterfaceID)
6919 {
6920 if (diff > 0)
6921 {
6922 mDNSu32 uTTL = RRUnadjustedTTL(cr->resrec.rroriginalttl);
6923 const mDNSs32 remain = uTTL - (m->timenow - cr->TimeRcvd) / mDNSPlatformOneSecond;
6924
6925 // -if we have slept longer than the remaining TTL, purge and start fresh.
6926 // -if we have been sleeping for a long time, we could reduce TimeRcvd below by
6927 // a sufficiently big value which could cause the value to go into the future
6928 // because of the signed comparison of time. For this to happen, we should have been
6929 // sleeping really long (~24 days). For now, we want to be conservative and flush even
6930 // if we have slept for more than two days.
6931
6932 if (diff >= remain || diff > (2 * 24 * 3600))
6933 {
6934 LogInfo("mDNSCoreMachineSleep: %s: Purging cache entry SleptTime %d, Remaining TTL %d",
6935 CRDisplayString(m, cr), diff, remain);
6936 mDNS_PurgeCacheResourceRecord(m, cr);
6937 continue;
6938 }
6939 cr->TimeRcvd -= (diff * mDNSPlatformOneSecond);
6940 if (m->timenow - (cr->TimeRcvd + ((mDNSs32)uTTL * mDNSPlatformOneSecond)) >= 0)
6941 {
6942 LogInfo("mDNSCoreMachineSleep: %s: Purging after adjusting the remaining TTL %d by %d seconds",
6943 CRDisplayString(m, cr), remain, diff);
6944 mDNS_PurgeCacheResourceRecord(m, cr);
6945 }
6946 else
6947 {
6948 LogInfo("mDNSCoreMachineSleep: %s: Adjusted the remain ttl %u by %d seconds", CRDisplayString(m, cr), remain, diff);
6949 }
6950 }
6951 }
6952 else
6953 {
6954 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForWake);
6955 }
6956 }
6957
6958 // 3. Retrigger probing and announcing for all our authoritative records
6959 for (rr = m->ResourceRecords; rr; rr=rr->next)
6960 {
6961 if (AuthRecord_uDNS(rr))
6962 {
6963 ActivateUnicastRegistration(m, rr);
6964 }
6965 else
6966 {
6967 mDNSCoreRestartRegistration(m, rr, -1);
6968 }
6969 }
6970
6971 // 4. Refresh NAT mappings
6972 // We don't want to have to assume that all hardware can necessarily keep accurate
6973 // track of passage of time while asleep, so on wake we refresh our NAT mappings.
6974 // We typically wake up with no interfaces active, so there's no need to rush to try to find our external address.
6975 // But if we do get a network configuration change, mDNSMacOSXNetworkChanged will call uDNS_SetupDNSConfig, which
6976 // will call mDNS_SetPrimaryInterfaceInfo, which will call RecreateNATMappings to refresh them, potentially sooner
6977 // than five seconds from now.
6978 LogInfo("mDNSCoreMachineSleep: recreating NAT mappings in 5 seconds");
6979 RecreateNATMappings(m, mDNSPlatformOneSecond * 5);
6980 mDNS_Unlock(m);
6981 }
6982}
6983
6984mDNSexport mDNSBool mDNSCoreReadyForSleep(mDNS *m, mDNSs32 now)
6985{
6986 DNSQuestion *q;
6987 AuthRecord *rr;
6988 NetworkInterfaceInfo *intf;
6989
6990 mDNS_Lock(m);
6991
6992 if (m->DelaySleep) goto notready;
6993
6994 // If we've not hit the sleep limit time, and it's not time for our next retry, we can skip these checks
6995 if (m->SleepLimit - now > 0 && m->NextScheduledSPRetry - now > 0) goto notready;
6996
6997 m->NextScheduledSPRetry = now + 0x40000000UL;
6998
6999 // See if we might need to retransmit any lost Sleep Proxy Registrations
7000 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
7001 if (intf->NextSPSAttempt >= 0)
7002 {
7003 if (now - intf->NextSPSAttemptTime >= 0)
7004 {
7005 LogSPS("mDNSCoreReadyForSleep: retrying for %s SPS %d try %d",
7006 intf->ifname, intf->NextSPSAttempt/3, intf->NextSPSAttempt);
7007 SendSPSRegistration(m, intf, zeroID);
7008 // Don't need to "goto notready" here, because if we do still have record registrations
7009 // that have not been acknowledged yet, we'll catch that in the record list scan below.
7010 }
7011 else
7012 if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0)
7013 m->NextScheduledSPRetry = intf->NextSPSAttemptTime;
7014 }
7015
7016 // Scan list of interfaces, and see if we're still waiting for any sleep proxy resolves to complete
7017 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
7018 {
7019 int sps = (intf->NextSPSAttempt == 0) ? 0 : (intf->NextSPSAttempt-1)/3;
7020 if (intf->NetWakeResolve[sps].ThisQInterval >= 0)
7021 {
7022 LogSPS("mDNSCoreReadyForSleep: waiting for SPS Resolve %s %##s (%s)",
7023 intf->ifname, intf->NetWakeResolve[sps].qname.c, DNSTypeName(intf->NetWakeResolve[sps].qtype));
7024 goto spsnotready;
7025 }
7026 }
7027
7028 // Scan list of registered records
7029 for (rr = m->ResourceRecords; rr; rr = rr->next)
7030 if (!AuthRecord_uDNS(rr))
7031 if (!mDNSOpaque64IsZero(&rr->updateIntID))
7032 { LogSPS("mDNSCoreReadyForSleep: waiting for SPS updateIntID 0x%x 0x%x (updateid %d) %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto spsnotready; }
7033
7034 // Scan list of private LLQs, and make sure they've all completed their handshake with the server
7035 for (q = m->Questions; q; q = q->next)
7036 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->ReqLease == 0 && q->tcp)
7037 {
7038 LogSPS("mDNSCoreReadyForSleep: waiting for LLQ %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
7039 goto notready;
7040 }
7041
7042 // Scan list of registered records
7043 for (rr = m->ResourceRecords; rr; rr = rr->next)
7044 if (AuthRecord_uDNS(rr))
7045 {
7046 if (rr->state == regState_Refresh && rr->tcp)
7047 { LogSPS("mDNSCoreReadyForSleep: waiting for Record updateIntID 0x%x 0x%x (updateid %d) %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto notready; }
7048 #if APPLE_OSX_mDNSResponder
7049 if (!RecordReadyForSleep(rr)) { LogSPS("mDNSCoreReadyForSleep: waiting for %s", ARDisplayString(m, rr)); goto notready; }
7050 #endif
7051 }
7052
7053 mDNS_Unlock(m);
7054 return mDNStrue;
7055
7056spsnotready:
7057
7058 // If we failed to complete sleep proxy registration within ten seconds, we give up on that
7059 // and allow up to ten seconds more to complete wide-area deregistration instead
7060 if (now - m->SleepLimit >= 0)
7061 {
7062 LogMsg("Failed to register with SPS, now sending goodbyes");
7063
7064 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
7065 if (intf->NetWakeBrowse.ThisQInterval >= 0)
7066 {
7067 LogSPS("ReadyForSleep mDNS_DeactivateNetWake %s %##s (%s)",
7068 intf->ifname, intf->NetWakeResolve[0].qname.c, DNSTypeName(intf->NetWakeResolve[0].qtype));
7069 mDNS_DeactivateNetWake_internal(m, intf);
7070 }
7071
7072 for (rr = m->ResourceRecords; rr; rr = rr->next)
7073 if (!AuthRecord_uDNS(rr))
7074 if (!mDNSOpaque64IsZero(&rr->updateIntID))
7075 {
7076 LogSPS("ReadyForSleep clearing updateIntID 0x%x 0x%x (updateid %d) for %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m, rr));
7077 rr->updateIntID = zeroOpaque64;
7078 }
7079
7080 // We'd really like to allow up to ten seconds more here,
7081 // but if we don't respond to the sleep notification within 30 seconds
7082 // we'll be put back to sleep forcibly without the chance to schedule the next maintenance wake.
7083 // Right now we wait 16 sec after wake for all the interfaces to come up, then we wait up to 10 seconds
7084 // more for SPS resolves and record registrations to complete, which puts us at 26 seconds.
7085 // If we allow just one more second to send our goodbyes, that puts us at 27 seconds.
7086 m->SleepLimit = now + mDNSPlatformOneSecond * 1;
7087
7088 SendSleepGoodbyes(m, mDNStrue, mDNStrue);
7089 }
7090
7091notready:
7092 mDNS_Unlock(m);
7093 return mDNSfalse;
7094}
7095
7096mDNSexport mDNSs32 mDNSCoreIntervalToNextWake(mDNS *const m, mDNSs32 now)
7097{
7098 AuthRecord *ar;
7099
7100 // Even when we have no wake-on-LAN-capable interfaces, or we failed to find a sleep proxy, or we have other
7101 // failure scenarios, we still want to wake up in at most 120 minutes, to see if the network environment has changed.
7102 // E.g. we might wake up and find no wireless network because the base station got rebooted just at that moment,
7103 // and if that happens we don't want to just give up and go back to sleep and never try again.
7104 mDNSs32 e = now + (120 * 60 * mDNSPlatformOneSecond); // Sleep for at most 120 minutes
7105
7106 NATTraversalInfo *nat;
7107 for (nat = m->NATTraversals; nat; nat=nat->next)
7108 if (nat->Protocol && nat->ExpiryTime && nat->ExpiryTime - now > mDNSPlatformOneSecond*4)
7109 {
7110 mDNSs32 t = nat->ExpiryTime - (nat->ExpiryTime - now) / 10; // Wake up when 90% of the way to the expiry time
7111 if (e - t > 0) e = t;
7112 LogSPS("ComputeWakeTime: %p %s Int %5d Ext %5d Err %d Retry %5d Interval %5d Expire %5d Wake %5d",
7113 nat, nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP",
7114 mDNSVal16(nat->IntPort), mDNSVal16(nat->ExternalPort), nat->Result,
7115 nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0,
7116 nat->retryInterval / mDNSPlatformOneSecond,
7117 nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0,
7118 (t - now) / mDNSPlatformOneSecond);
7119 }
7120
7121 // This loop checks both the time we need to renew wide-area registrations,
7122 // and the time we need to renew Sleep Proxy registrations
7123 for (ar = m->ResourceRecords; ar; ar = ar->next)
7124 if (ar->expire && ar->expire - now > mDNSPlatformOneSecond*4)
7125 {
7126 mDNSs32 t = ar->expire - (ar->expire - now) / 10; // Wake up when 90% of the way to the expiry time
7127 if (e - t > 0) e = t;
7128 LogSPS("ComputeWakeTime: %p Int %7d Next %7d Expire %7d Wake %7d %s",
7129 ar, ar->ThisAPInterval / mDNSPlatformOneSecond,
7130 (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond,
7131 ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0,
7132 (t - now) / mDNSPlatformOneSecond, ARDisplayString(m, ar));
7133 }
7134
7135 return(e - now);
7136}
7137
7138// ***************************************************************************
7139#if COMPILER_LIKES_PRAGMA_MARK
7140#pragma mark -
7141#pragma mark - Packet Reception Functions
7142#endif
7143
7144#define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo)
7145
7146mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end,
7147 const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, DNSMessage *const response, AuthRecord *ResponseRecords)
7148{
7149 mDNSu8 *responseptr = response->data;
7150 const mDNSu8 *const limit = response->data + sizeof(response->data);
7151 const mDNSu8 *ptr = query->data;
7152 AuthRecord *rr;
7153 mDNSu32 maxttl = 0x70000000;
7154 int i;
7155
7156 // Initialize the response fields so we can answer the questions
7157 InitializeDNSMessage(&response->h, query->h.id, ResponseFlags);
7158
7159 // ***
7160 // *** 1. Write out the list of questions we are actually going to answer with this packet
7161 // ***
7162 if (LegacyQuery)
7163 {
7164 maxttl = kStaticCacheTTL;
7165 for (i=0; i<query->h.numQuestions; i++) // For each question...
7166 {
7167 DNSQuestion q;
7168 ptr = getQuestion(query, ptr, end, InterfaceID, &q); // get the question...
7169 if (!ptr) return(mDNSNULL);
7170
7171 for (rr=ResponseRecords; rr; rr=rr->NextResponse) // and search our list of proposed answers
7172 {
7173 if (rr->NR_AnswerTo == ptr) // If we're going to generate a record answering this question
7174 { // then put the question in the question section
7175 responseptr = putQuestion(response, responseptr, limit, &q.qname, q.qtype, q.qclass);
7176 if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL); }
7177 break; // break out of the ResponseRecords loop, and go on to the next question
7178 }
7179 }
7180 }
7181
7182 if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL); }
7183 }
7184
7185 // ***
7186 // *** 2. Write Answers
7187 // ***
7188 for (rr=ResponseRecords; rr; rr=rr->NextResponse)
7189 if (rr->NR_AnswerTo)
7190 {
7191 mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAnswers, &rr->resrec,
7192 maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl);
7193 if (p) responseptr = p;
7194 else { debugf("GenerateUnicastResponse: Ran out of space for answers!"); response->h.flags.b[0] |= kDNSFlag0_TC; }
7195 }
7196
7197 // ***
7198 // *** 3. Write Additionals
7199 // ***
7200 for (rr=ResponseRecords; rr; rr=rr->NextResponse)
7201 if (rr->NR_AdditionalTo && !rr->NR_AnswerTo)
7202 {
7203 mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAdditionals, &rr->resrec,
7204 maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl);
7205 if (p) responseptr = p;
7206 else debugf("GenerateUnicastResponse: No more space for additionals");
7207 }
7208
7209 return(responseptr);
7210}
7211
7212// AuthRecord *our is our Resource Record
7213// CacheRecord *pkt is the Resource Record from the response packet we've witnessed on the network
7214// Returns 0 if there is no conflict
7215// Returns +1 if there was a conflict and we won
7216// Returns -1 if there was a conflict and we lost and have to rename
7217mDNSlocal int CompareRData(const AuthRecord *const our, const CacheRecord *const pkt)
7218{
7219 mDNSu8 ourdata[256], *ourptr = ourdata, *ourend;
7220 mDNSu8 pktdata[256], *pktptr = pktdata, *pktend;
7221 if (!our) { LogMsg("CompareRData ERROR: our is NULL"); return(+1); }
7222 if (!pkt) { LogMsg("CompareRData ERROR: pkt is NULL"); return(+1); }
7223
7224 ourend = putRData(mDNSNULL, ourdata, ourdata + sizeof(ourdata), &our->resrec);
7225 pktend = putRData(mDNSNULL, pktdata, pktdata + sizeof(pktdata), &pkt->resrec);
7226 while (ourptr < ourend && pktptr < pktend && *ourptr == *pktptr) { ourptr++; pktptr++; }
7227 if (ourptr >= ourend && pktptr >= pktend) return(0); // If data identical, not a conflict
7228
7229 if (ourptr >= ourend) return(-1); // Our data ran out first; We lost
7230 if (pktptr >= pktend) return(+1); // Packet data ran out first; We won
7231 if (*pktptr > *ourptr) return(-1); // Our data is numerically lower; We lost
7232 if (*pktptr < *ourptr) return(+1); // Packet data is numerically lower; We won
7233
7234 LogMsg("CompareRData ERROR: Invalid state");
7235 return(-1);
7236}
7237
7238// See if we have an authoritative record that's identical to this packet record,
7239// whose canonical DependentOn record is the specified master record.
7240// The DependentOn pointer is typically used for the TXT record of service registrations
7241// It indicates that there is no inherent conflict detection for the TXT record
7242// -- it depends on the SRV record to resolve name conflicts
7243// If we find any identical ResourceRecords in our authoritative list, then follow their DependentOn
7244// pointer chain (if any) to make sure we reach the canonical DependentOn record
7245// If the record has no DependentOn, then just return that record's pointer
7246// Returns NULL if we don't have any local RRs that are identical to the one from the packet
7247mDNSlocal mDNSBool MatchDependentOn(const mDNS *const m, const CacheRecord *const pktrr, const AuthRecord *const master)
7248{
7249 const AuthRecord *r1;
7250 for (r1 = m->ResourceRecords; r1; r1=r1->next)
7251 {
7252 if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec))
7253 {
7254 const AuthRecord *r2 = r1;
7255 while (r2->DependentOn) r2 = r2->DependentOn;
7256 if (r2 == master) return(mDNStrue);
7257 }
7258 }
7259 for (r1 = m->DuplicateRecords; r1; r1=r1->next)
7260 {
7261 if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec))
7262 {
7263 const AuthRecord *r2 = r1;
7264 while (r2->DependentOn) r2 = r2->DependentOn;
7265 if (r2 == master) return(mDNStrue);
7266 }
7267 }
7268 return(mDNSfalse);
7269}
7270
7271// Find the canonical RRSet pointer for this RR received in a packet.
7272// If we find any identical AuthRecord in our authoritative list, then follow its RRSet
7273// pointers (if any) to make sure we return the canonical member of this name/type/class
7274// Returns NULL if we don't have any local RRs that are identical to the one from the packet
7275mDNSlocal const AuthRecord *FindRRSet(const mDNS *const m, const CacheRecord *const pktrr)
7276{
7277 const AuthRecord *rr;
7278 for (rr = m->ResourceRecords; rr; rr=rr->next)
7279 {
7280 if (IdenticalResourceRecord(&rr->resrec, &pktrr->resrec))
7281 {
7282 while (rr->RRSet && rr != rr->RRSet) rr = rr->RRSet;
7283 return(rr);
7284 }
7285 }
7286 return(mDNSNULL);
7287}
7288
7289// PacketRRConflict is called when we've received an RR (pktrr) which has the same name
7290// as one of our records (our) but different rdata.
7291// 1. If our record is not a type that's supposed to be unique, we don't care.
7292// 2a. If our record is marked as dependent on some other record for conflict detection, ignore this one.
7293// 2b. If the packet rr exactly matches one of our other RRs, and *that* record's DependentOn pointer
7294// points to our record, ignore this conflict (e.g. the packet record matches one of our
7295// TXT records, and that record is marked as dependent on 'our', its SRV record).
7296// 3. If we have some *other* RR that exactly matches the one from the packet, and that record and our record
7297// are members of the same RRSet, then this is not a conflict.
7298mDNSlocal mDNSBool PacketRRConflict(const mDNS *const m, const AuthRecord *const our, const CacheRecord *const pktrr)
7299{
7300 // If not supposed to be unique, not a conflict
7301 if (!(our->resrec.RecordType & kDNSRecordTypeUniqueMask)) return(mDNSfalse);
7302
7303 // If a dependent record, not a conflict
7304 if (our->DependentOn || MatchDependentOn(m, pktrr, our)) return(mDNSfalse);
7305 else
7306 {
7307 // If the pktrr matches a member of ourset, not a conflict
7308 const AuthRecord *ourset = our->RRSet ? our->RRSet : our;
7309 const AuthRecord *pktset = FindRRSet(m, pktrr);
7310 if (pktset == ourset) return(mDNSfalse);
7311
7312 // For records we're proxying, where we don't know the full
7313 // relationship between the records, having any matching record
7314 // in our AuthRecords list is sufficient evidence of non-conflict
7315 if (our->WakeUp.HMAC.l[0] && pktset) return(mDNSfalse);
7316 }
7317
7318 // Okay, this is a conflict
7319 return(mDNStrue);
7320}
7321
7322// Note: ResolveSimultaneousProbe calls mDNS_Deregister_internal which can call a user callback, which may change
7323// the record list and/or question list.
7324// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
7325mDNSlocal void ResolveSimultaneousProbe(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
7326 DNSQuestion *q, AuthRecord *our)
7327{
7328 int i;
7329 const mDNSu8 *ptr = LocateAuthorities(query, end);
7330 mDNSBool FoundUpdate = mDNSfalse;
7331
7332 for (i = 0; i < query->h.numAuthorities; i++)
7333 {
7334 ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
7335 if (!ptr) break;
7336 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && ResourceRecordAnswersQuestion(&m->rec.r.resrec, q))
7337 {
7338 FoundUpdate = mDNStrue;
7339 if (PacketRRConflict(m, our, &m->rec.r))
7340 {
7341 int result = (int)our->resrec.rrclass - (int)m->rec.r.resrec.rrclass;
7342 if (!result) result = (int)our->resrec.rrtype - (int)m->rec.r.resrec.rrtype;
7343 if (!result) result = CompareRData(our, &m->rec.r);
7344 if (result)
7345 {
7346 const char *const msg = (result < 0) ? "lost:" : (result > 0) ? "won: " : "tie: ";
7347 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r));
7348 LogMsg("ResolveSimultaneousProbe: %p Our Record %d %s %08lX %s", our->resrec.InterfaceID, our->ProbeCount, msg, our->resrec.rdatahash, ARDisplayString(m, our));
7349 }
7350 // If we lost the tie-break for simultaneous probes, we don't immediately give up, because we might be seeing stale packets on the network.
7351 // Instead we pause for one second, to give the other host (if real) a chance to establish its name, and then try probing again.
7352 // If there really is another live host out there with the same name, it will answer our probes and we'll then rename.
7353 if (result < 0)
7354 {
7355 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond);
7356 our->ProbeCount = DefaultProbeCountForTypeUnique;
7357 our->AnnounceCount = InitialAnnounceCount;
7358 InitializeLastAPTime(m, our);
7359 goto exit;
7360 }
7361 }
7362#if 0
7363 else
7364 {
7365 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r));
7366 LogMsg("ResolveSimultaneousProbe: %p Our Record %d ign: %08lX %s", our->resrec.InterfaceID, our->ProbeCount, our->resrec.rdatahash, ARDisplayString(m, our));
7367 }
7368#endif
7369 }
7370 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
7371 }
7372 if (!FoundUpdate)
7373 LogInfo("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
7374exit:
7375 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
7376}
7377
7378mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, const ResourceRecord *const pktrr)
7379{
7380 CacheGroup *cg = CacheGroupForRecord(m, pktrr);
7381 CacheRecord *rr;
7382 mDNSBool match;
7383 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
7384 {
7385 if (!pktrr->InterfaceID)
7386 {
7387 mDNSu16 id1 = (pktrr->rDNSServer ? pktrr->rDNSServer->resGroupID : 0);
7388 mDNSu16 id2 = (rr->resrec.rDNSServer ? rr->resrec.rDNSServer->resGroupID : 0);
7389 match = (id1 == id2);
7390 }
7391 else match = (pktrr->InterfaceID == rr->resrec.InterfaceID);
7392
7393 if (match && IdenticalSameNameRecord(pktrr, &rr->resrec)) break;
7394 }
7395 return(rr);
7396}
7397mDNSlocal void DeregisterProxyRecord(mDNS *const m, AuthRecord *const rr)
7398{
7399 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host
7400 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it
7401 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
7402 SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID);
7403}
7404
7405mDNSlocal void ClearKeepaliveProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist, const mDNSInterfaceID InterfaceID)
7406{
7407 if (m->CurrentRecord)
7408 LogMsg("ClearKeepaliveProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
7409 m->CurrentRecord = thelist;
7410
7411 // Normally, the RDATA of the keepalive record will be different each time and hence we always
7412 // clean up the keepalive record.
7413 while (m->CurrentRecord)
7414 {
7415 AuthRecord *const rr = m->CurrentRecord;
7416 if (InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC))
7417 {
7418 if (mDNS_KeepaliveRecord(&m->rec.r.resrec))
7419 {
7420 LogSPS("ClearKeepaliveProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s",
7421 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr));
7422 DeregisterProxyRecord(m, rr);
7423 }
7424 }
7425 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
7426 // new records could have been added to the end of the list as a result of that call.
7427 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
7428 m->CurrentRecord = rr->next;
7429 }
7430}
7431
7432// Called from mDNSCoreReceiveUpdate when we get a sleep proxy registration request,
7433// to check our lists and discard any stale duplicates of this record we already have
7434mDNSlocal void ClearIdenticalProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist)
7435{
7436 if (m->CurrentRecord)
7437 LogMsg("ClearIdenticalProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
7438 m->CurrentRecord = thelist;
7439 while (m->CurrentRecord)
7440 {
7441 AuthRecord *const rr = m->CurrentRecord;
7442 if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC))
7443 if (IdenticalResourceRecord(&rr->resrec, &m->rec.r.resrec))
7444 {
7445 LogSPS("ClearIdenticalProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s",
7446 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr));
7447 DeregisterProxyRecord(m, rr);
7448 }
7449 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
7450 // new records could have been added to the end of the list as a result of that call.
7451 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
7452 m->CurrentRecord = rr->next;
7453 }
7454}
7455
7456// Called from ProcessQuery when we get an mDNS packet with an owner record in it
7457mDNSlocal void ClearProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist)
7458{
7459 if (m->CurrentRecord)
7460 LogMsg("ClearProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
7461 m->CurrentRecord = thelist;
7462 while (m->CurrentRecord)
7463 {
7464 AuthRecord *const rr = m->CurrentRecord;
7465 if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC))
7466 if (owner->seq != rr->WakeUp.seq || m->timenow - rr->TimeRcvd > mDNSPlatformOneSecond * 60)
7467 {
7468 if (rr->AddressProxy.type == mDNSAddrType_IPv6)
7469 {
7470 // We don't do this here because we know that the host is waking up at this point, so we don't send
7471 // Unsolicited Neighbor Advertisements -- even Neighbor Advertisements agreeing with what the host should be
7472 // saying itself -- because it can cause some IPv6 stacks to falsely conclude that there's an address conflict.
7473 #if MDNS_USE_Unsolicited_Neighbor_Advertisements
7474 LogSPS("NDP Announcement -- Releasing traffic for H-MAC %.6a I-MAC %.6a %s",
7475 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr));
7476 SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, &rr->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth);
7477 #endif
7478 }
7479 LogSPS("ClearProxyRecords: Removing %3d AC %2d %02X H-MAC %.6a I-MAC %.6a %d %d %s",
7480 m->ProxyRecords, rr->AnnounceCount, rr->resrec.RecordType,
7481 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr));
7482 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) rr->resrec.RecordType = kDNSRecordTypeShared;
7483 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host
7484 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it, since real host is now back and functional
7485 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
7486 SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID);
7487 }
7488 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
7489 // new records could have been added to the end of the list as a result of that call.
7490 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
7491 m->CurrentRecord = rr->next;
7492 }
7493}
7494
7495// ProcessQuery examines a received query to see if we have any answers to give
7496mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
7497 const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast,
7498 mDNSBool QueryWasLocalUnicast, DNSMessage *const response)
7499{
7500 mDNSBool FromLocalSubnet = srcaddr && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr);
7501 AuthRecord *ResponseRecords = mDNSNULL;
7502 AuthRecord **nrp = &ResponseRecords;
7503
7504#if POOF_ENABLED
7505 CacheRecord *ExpectedAnswers = mDNSNULL; // Records in our cache we expect to see updated
7506 CacheRecord **eap = &ExpectedAnswers;
7507#endif // POOF_ENABLED
7508
7509 DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet
7510 DNSQuestion **dqp = &DupQuestions;
7511 mDNSs32 delayresponse = 0;
7512 mDNSBool SendLegacyResponse = mDNSfalse;
7513 const mDNSu8 *ptr;
7514 mDNSu8 *responseptr = mDNSNULL;
7515 AuthRecord *rr;
7516 int i;
7517 CacheRecord *McastNSEC3Records = mDNSNULL;
7518
7519 // ***
7520 // *** 1. Look in Additional Section for an OPT record
7521 // ***
7522 ptr = LocateOptRR(query, end, DNSOpt_OwnerData_ID_Space);
7523 if (ptr)
7524 {
7525 ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAdd, &m->rec);
7526 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT)
7527 {
7528 const rdataOPT *opt;
7529 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength];
7530 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently
7531 // delete all our own AuthRecords (which are identified by having zero MAC tags on them).
7532 for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++)
7533 if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0])
7534 {
7535 ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords);
7536 ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords);
7537 }
7538 }
7539 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
7540 }
7541
7542 //
7543 // Look in Authority Section for NSEC3 record
7544 //
7545
7546 mDNSParseNSEC3Records(m, query, end, InterfaceID, &McastNSEC3Records);
7547
7548 // ***
7549 // *** 2. Parse Question Section and mark potential answers
7550 // ***
7551 ptr = query->data;
7552 for (i=0; i<query->h.numQuestions; i++) // For each question...
7553 {
7554 mDNSBool QuestionNeedsMulticastResponse;
7555 int NumAnswersForThisQuestion = 0;
7556 AuthRecord *NSECAnswer = mDNSNULL;
7557 DNSQuestion pktq, *q;
7558 ptr = getQuestion(query, ptr, end, InterfaceID, &pktq); // get the question...
7559 if (!ptr) goto exit;
7560
7561 pktq.AnonInfo = mDNSNULL;
7562 if (McastNSEC3Records)
7563 InitializeAnonInfoForQuestion(m, &McastNSEC3Records, &pktq);
7564 // The only queries that *need* a multicast response are:
7565 // * Queries sent via multicast
7566 // * from port 5353
7567 // * that don't have the kDNSQClass_UnicastResponse bit set
7568 // These queries need multicast responses because other clients will:
7569 // * suppress their own identical questions when they see these questions, and
7570 // * expire their cache records if they don't see the expected responses
7571 // For other queries, we may still choose to send the occasional multicast response anyway,
7572 // to keep our neighbours caches warm, and for ongoing conflict detection.
7573 QuestionNeedsMulticastResponse = QueryWasMulticast && !LegacyQuery && !(pktq.qclass & kDNSQClass_UnicastResponse);
7574
7575 if (pktq.qclass & kDNSQClass_UnicastResponse)
7576 m->mDNSStats.UnicastBitInQueries++;
7577 else
7578 m->mDNSStats.NormalQueries++;
7579
7580 // Clear the UnicastResponse flag -- don't want to confuse the rest of the code that follows later
7581 pktq.qclass &= ~kDNSQClass_UnicastResponse;
7582
7583 // Note: We use the m->CurrentRecord mechanism here because calling ResolveSimultaneousProbe
7584 // can result in user callbacks which may change the record list and/or question list.
7585 // Also note: we just mark potential answer records here, without trying to build the
7586 // "ResponseRecords" list, because we don't want to risk user callbacks deleting records
7587 // from that list while we're in the middle of trying to build it.
7588 if (m->CurrentRecord)
7589 LogMsg("ProcessQuery ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
7590 m->CurrentRecord = m->ResourceRecords;
7591 while (m->CurrentRecord)
7592 {
7593 rr = m->CurrentRecord;
7594 m->CurrentRecord = rr->next;
7595 if (AnyTypeRecordAnswersQuestion(&rr->resrec, &pktq) && (QueryWasMulticast || QueryWasLocalUnicast || rr->AllowRemoteQuery))
7596 {
7597 m->mDNSStats.MatchingAnswersForQueries++;
7598 if (RRTypeAnswersQuestionType(&rr->resrec, pktq.qtype))
7599 {
7600 if (rr->resrec.RecordType == kDNSRecordTypeUnique)
7601 ResolveSimultaneousProbe(m, query, end, &pktq, rr);
7602 else if (ResourceRecordIsValidAnswer(rr))
7603 {
7604 NumAnswersForThisQuestion++;
7605 // As we have verified this question to be part of the same subset,
7606 // set the anonymous data which is needed below when walk the cache
7607 // records to see what answers we should be expecting. The cache records
7608 // may cache only the nsec3RR and not the anonymous data itself.
7609 if (pktq.AnonInfo && rr->resrec.AnonInfo)
7610 SetAnonData(&pktq, &rr->resrec, mDNStrue);
7611
7612 // Note: We should check here if this is a probe-type query, and if so, generate an immediate
7613 // unicast answer back to the source, because timeliness in answering probes is important.
7614
7615 // Notes:
7616 // NR_AnswerTo pointing into query packet means "answer via immediate legacy unicast" (may *also* choose to multicast)
7617 // NR_AnswerTo == NR_AnswerUnicast means "answer via delayed unicast" (to modern querier; may promote to multicast instead)
7618 // NR_AnswerTo == NR_AnswerMulticast means "definitely answer via multicast" (can't downgrade to unicast later)
7619 // If we're not multicasting this record because the kDNSQClass_UnicastResponse bit was set,
7620 // but the multicast querier is not on a matching subnet (e.g. because of overlaid subnets on one link)
7621 // then we'll multicast it anyway (if we unicast, the receiver will ignore it because it has an apparently non-local source)
7622 if (QuestionNeedsMulticastResponse || (!FromLocalSubnet && QueryWasMulticast && !LegacyQuery))
7623 {
7624 // We only mark this question for sending if it is at least one second since the last time we multicast it
7625 // on this interface. If it is more than a second, or LastMCInterface is different, then we may multicast it.
7626 // This is to guard against the case where someone blasts us with queries as fast as they can.
7627 if ((mDNSu32)(m->timenow - rr->LastMCTime) >= (mDNSu32)mDNSPlatformOneSecond ||
7628 (rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID))
7629 rr->NR_AnswerTo = NR_AnswerMulticast;
7630 }
7631 else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = LegacyQuery ? ptr : NR_AnswerUnicast;
7632 }
7633 }
7634 else if ((rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && ResourceRecordIsValidAnswer(rr))
7635 {
7636 // If we don't have any answers for this question, but we do own another record with the same name,
7637 // then we'll want to mark it to generate an NSEC record on this interface
7638 if (!NSECAnswer) NSECAnswer = rr;
7639 }
7640 }
7641 }
7642
7643 if (NumAnswersForThisQuestion == 0 && NSECAnswer)
7644 {
7645 NumAnswersForThisQuestion++;
7646 NSECAnswer->SendNSECNow = InterfaceID;
7647 m->NextScheduledResponse = m->timenow;
7648 }
7649
7650 // If we couldn't answer this question, someone else might be able to,
7651 // so use random delay on response to reduce collisions
7652 if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
7653
7654 if (query->h.flags.b[0] & kDNSFlag0_TC)
7655 m->mDNSStats.KnownAnswerMultiplePkts++;
7656 // We only do the following accelerated cache expiration and duplicate question suppression processing
7657 // for non-truncated multicast queries with multicast responses.
7658 // For any query generating a unicast response we don't do this because we can't assume we will see the response.
7659 // For truncated queries we don't do this because a response we're expecting might be suppressed by a subsequent
7660 // known-answer packet, and when there's packet loss we can't safely assume we'll receive *all* known-answer packets.
7661 if (QuestionNeedsMulticastResponse && !(query->h.flags.b[0] & kDNSFlag0_TC))
7662 {
7663#if POOF_ENABLED
7664 CacheGroup *cg = CacheGroupForName(m, pktq.qnamehash, &pktq.qname);
7665 CacheRecord *cr;
7666
7667 // Make a list indicating which of our own cache records we expect to see updated as a result of this query
7668 // Note: Records larger than 1K are not habitually multicast, so don't expect those to be updated
7669 for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next)
7670 if (SameNameRecordAnswersQuestion(&cr->resrec, &pktq) && cr->resrec.rdlength <= SmallRecordLimit)
7671 if (!cr->NextInKAList && eap != &cr->NextInKAList)
7672 {
7673 *eap = cr;
7674 eap = &cr->NextInKAList;
7675 }
7676#endif // POOF_ENABLED
7677
7678 // Check if this question is the same as any of mine.
7679 // We only do this for non-truncated queries. Right now it would be too complicated to try
7680 // to keep track of duplicate suppression state between multiple packets, especially when we
7681 // can't guarantee to receive all of the Known Answer packets that go with a particular query.
7682 // For anonymous question, the duplicate suppressesion should happen if the
7683 // question belongs in the same group. As the group is expected to be
7684 // small, we don't do the optimization for now.
7685 if (!pktq.AnonInfo)
7686 {
7687 for (q = m->Questions; q; q=q->next)
7688 if (!q->Target.type && ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4)
7689 if (!q->InterfaceID || q->InterfaceID == InterfaceID)
7690 if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList)
7691 if (q->qtype == pktq.qtype &&
7692 q->qclass == pktq.qclass &&
7693 q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname))
7694 { *dqp = q; dqp = &q->NextInDQList; }
7695 }
7696 }
7697 if (pktq.AnonInfo)
7698 {
7699 FreeAnonInfo(pktq.AnonInfo);
7700 }
7701 }
7702
7703 // ***
7704 // *** 3. Now we can safely build the list of marked answers
7705 // ***
7706 for (rr = m->ResourceRecords; rr; rr=rr->next) // Now build our list of potential answers
7707 if (rr->NR_AnswerTo) // If we marked the record...
7708 AddRecordToResponseList(&nrp, rr, mDNSNULL); // ... add it to the list
7709
7710 // ***
7711 // *** 4. Add additional records
7712 // ***
7713 AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID);
7714
7715 // ***
7716 // *** 5. Parse Answer Section and cancel any records disallowed by Known-Answer list
7717 // ***
7718 for (i=0; i<query->h.numAnswers; i++) // For each record in the query's answer section...
7719 {
7720 // Get the record...
7721 CacheRecord *ourcacherr;
7722 ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &m->rec);
7723 if (!ptr) goto exit;
7724 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative)
7725 {
7726 // See if this Known-Answer suppresses any of our currently planned answers
7727 for (rr=ResponseRecords; rr; rr=rr->NextResponse)
7728 {
7729 if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&m->rec.r, rr))
7730 {
7731 m->mDNSStats.KnownAnswerSuppressions++;
7732 rr->NR_AnswerTo = mDNSNULL;
7733 rr->NR_AdditionalTo = mDNSNULL;
7734 }
7735 }
7736
7737 // See if this Known-Answer suppresses any previously scheduled answers (for multi-packet KA suppression)
7738 for (rr=m->ResourceRecords; rr; rr=rr->next)
7739 {
7740 // If we're planning to send this answer on this interface, and only on this interface, then allow KA suppression
7741 if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&m->rec.r, rr))
7742 {
7743 if (srcaddr->type == mDNSAddrType_IPv4)
7744 {
7745 if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zerov4Addr;
7746 }
7747 else if (srcaddr->type == mDNSAddrType_IPv6)
7748 {
7749 if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr;
7750 }
7751 if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester))
7752 {
7753 m->mDNSStats.KnownAnswerSuppressions++;
7754 rr->ImmedAnswer = mDNSNULL;
7755 rr->ImmedUnicast = mDNSfalse;
7756 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
7757 LogMsg("Suppressed after%4d: %s", m->timenow - rr->ImmedAnswerMarkTime, ARDisplayString(m, rr));
7758 #endif
7759 }
7760 }
7761 }
7762
7763 ourcacherr = FindIdenticalRecordInCache(m, &m->rec.r.resrec);
7764
7765#if POOF_ENABLED
7766 // Having built our ExpectedAnswers list from the questions in this packet, we then remove
7767 // any records that are suppressed by the Known Answer list in this packet.
7768 eap = &ExpectedAnswers;
7769 while (*eap)
7770 {
7771 CacheRecord *cr = *eap;
7772 if (cr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&m->rec.r.resrec, &cr->resrec))
7773 { *eap = cr->NextInKAList; cr->NextInKAList = mDNSNULL; }
7774 else eap = &cr->NextInKAList;
7775 }
7776#endif // POOF_ENABLED
7777
7778 // See if this Known-Answer is a surprise to us. If so, we shouldn't suppress our own query.
7779 if (!ourcacherr)
7780 {
7781 dqp = &DupQuestions;
7782 while (*dqp)
7783 {
7784 DNSQuestion *q = *dqp;
7785 if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q))
7786 { *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; }
7787 else dqp = &q->NextInDQList;
7788 }
7789 }
7790 }
7791 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
7792 }
7793
7794 // ***
7795 // *** 6. Cancel any additionals that were added because of now-deleted records
7796 // ***
7797 for (rr=ResponseRecords; rr; rr=rr->NextResponse)
7798 if (rr->NR_AdditionalTo && !MustSendRecord(rr->NR_AdditionalTo))
7799 { rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
7800
7801 // ***
7802 // *** 7. Mark the send flags on the records we plan to send
7803 // ***
7804 for (rr=ResponseRecords; rr; rr=rr->NextResponse)
7805 {
7806 if (rr->NR_AnswerTo)
7807 {
7808 mDNSBool SendMulticastResponse = mDNSfalse; // Send modern multicast response
7809 mDNSBool SendUnicastResponse = mDNSfalse; // Send modern unicast response (not legacy unicast response)
7810
7811 // If it's been one TTL/4 since we multicast this, then send a multicast response
7812 // for conflict detection, etc.
7813 if ((mDNSu32)(m->timenow - rr->LastMCTime) >= (mDNSu32)TicksTTL(rr)/4)
7814 {
7815 SendMulticastResponse = mDNStrue;
7816 // If this record was marked for modern (delayed) unicast response, then mark it as promoted to
7817 // multicast response instead (don't want to end up ALSO setting SendUnicastResponse in the check below).
7818 // If this record was marked for legacy unicast response, then we mustn't change the NR_AnswerTo value.
7819 if (rr->NR_AnswerTo == NR_AnswerUnicast)
7820 {
7821 m->mDNSStats.UnicastDemotedToMulticast++;
7822 rr->NR_AnswerTo = NR_AnswerMulticast;
7823 }
7824 }
7825
7826 // If the client insists on a multicast response, then we'd better send one
7827 if (rr->NR_AnswerTo == NR_AnswerMulticast)
7828 {
7829 m->mDNSStats.MulticastResponses++;
7830 SendMulticastResponse = mDNStrue;
7831 }
7832 else if (rr->NR_AnswerTo == NR_AnswerUnicast)
7833 {
7834 m->mDNSStats.UnicastResponses++;
7835 SendUnicastResponse = mDNStrue;
7836 }
7837 else if (rr->NR_AnswerTo)
7838 {
7839 SendLegacyResponse = mDNStrue;
7840 }
7841
7842 if (SendMulticastResponse || SendUnicastResponse)
7843 {
7844#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
7845 rr->ImmedAnswerMarkTime = m->timenow;
7846#endif
7847 m->NextScheduledResponse = m->timenow;
7848 // If we're already planning to send this on another interface, just send it on all interfaces
7849 if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID)
7850 rr->ImmedAnswer = mDNSInterfaceMark;
7851 else
7852 {
7853 rr->ImmedAnswer = InterfaceID; // Record interface to send it on
7854 if (SendUnicastResponse) rr->ImmedUnicast = mDNStrue;
7855 if (srcaddr->type == mDNSAddrType_IPv4)
7856 {
7857 if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4;
7858 else if (!mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = onesIPv4Addr;
7859 }
7860 else if (srcaddr->type == mDNSAddrType_IPv6)
7861 {
7862 if (mDNSIPv6AddressIsZero(rr->v6Requester)) rr->v6Requester = srcaddr->ip.v6;
7863 else if (!mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = onesIPv6Addr;
7864 }
7865 }
7866 }
7867 // If TC flag is set, it means we should expect that additional known answers may be coming in another packet,
7868 // so we allow roughly half a second before deciding to reply (we've observed inter-packet delays of 100-200ms on 802.11)
7869 // else, if record is a shared one, spread responses over 100ms to avoid implosion of simultaneous responses
7870 // else, for a simple unique record reply, we can reply immediately; no need for delay
7871 if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; // Divided by 50 = 400ms
7872 else if (rr->resrec.RecordType == kDNSRecordTypeShared) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
7873 }
7874 else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == NR_AnswerMulticast)
7875 {
7876 // Since additional records are an optimization anyway, we only ever send them on one interface at a time
7877 // If two clients on different interfaces do queries that invoke the same optional additional answer,
7878 // then the earlier client is out of luck
7879 rr->ImmedAdditional = InterfaceID;
7880 // No need to set m->NextScheduledResponse here
7881 // We'll send these additional records when we send them, or not, as the case may be
7882 }
7883 }
7884
7885 // ***
7886 // *** 8. If we think other machines are likely to answer these questions, set our packet suppression timer
7887 // ***
7888 if (delayresponse && (!m->SuppressSending || (m->SuppressSending - m->timenow) < (delayresponse + 49) / 50))
7889 {
7890#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
7891 mDNSs32 oldss = m->SuppressSending;
7892 if (oldss && delayresponse)
7893 LogMsg("Current SuppressSending delay%5ld; require%5ld", m->SuppressSending - m->timenow, (delayresponse + 49) / 50);
7894#endif
7895 // Pick a random delay:
7896 // We start with the base delay chosen above (typically either 1 second or 20 seconds),
7897 // and add a random value in the range 0-5 seconds (making 1-6 seconds or 20-25 seconds).
7898 // This is an integer value, with resolution determined by the platform clock rate.
7899 // We then divide that by 50 to get the delay value in ticks. We defer the division until last
7900 // to get better results on platforms with coarse clock granularity (e.g. ten ticks per second).
7901 // The +49 before dividing is to ensure we round up, not down, to ensure that even
7902 // on platforms where the native clock rate is less than fifty ticks per second,
7903 // we still guarantee that the final calculated delay is at least one platform tick.
7904 // We want to make sure we don't ever allow the delay to be zero ticks,
7905 // because if that happens we'll fail the Bonjour Conformance Test.
7906 // Our final computed delay is 20-120ms for normal delayed replies,
7907 // or 400-500ms in the case of multi-packet known-answer lists.
7908 m->SuppressSending = m->timenow + (delayresponse + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*5) + 49) / 50;
7909 if (m->SuppressSending == 0) m->SuppressSending = 1;
7910#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
7911 if (oldss && delayresponse)
7912 LogMsg("Set SuppressSending to %5ld", m->SuppressSending - m->timenow);
7913#endif
7914 }
7915
7916 // ***
7917 // *** 9. If query is from a legacy client, or from a new client requesting a unicast reply, then generate a unicast response too
7918 // ***
7919 if (SendLegacyResponse)
7920 responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords);
7921
7922exit:
7923 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
7924
7925 // ***
7926 // *** 10. Finally, clear our link chains ready for use next time
7927 // ***
7928 while (ResponseRecords)
7929 {
7930 rr = ResponseRecords;
7931 ResponseRecords = rr->NextResponse;
7932 rr->NextResponse = mDNSNULL;
7933 rr->NR_AnswerTo = mDNSNULL;
7934 rr->NR_AdditionalTo = mDNSNULL;
7935 }
7936
7937#if POOF_ENABLED
7938 while (ExpectedAnswers)
7939 {
7940 CacheRecord *cr = ExpectedAnswers;
7941 ExpectedAnswers = cr->NextInKAList;
7942 cr->NextInKAList = mDNSNULL;
7943
7944 // For non-truncated queries, we can definitively say that we should expect
7945 // to be seeing a response for any records still left in the ExpectedAnswers list
7946 if (!(query->h.flags.b[0] & kDNSFlag0_TC))
7947 if (cr->UnansweredQueries == 0 || m->timenow - cr->LastUnansweredTime >= mDNSPlatformOneSecond * 3/4)
7948 {
7949 cr->UnansweredQueries++;
7950 cr->LastUnansweredTime = m->timenow;
7951 if (cr->UnansweredQueries > 1)
7952 debugf("ProcessQuery: UnansweredQueries %lu %s", cr->UnansweredQueries, CRDisplayString(m, cr));
7953 SetNextCacheCheckTimeForRecord(m, cr);
7954 }
7955
7956 // If we've seen multiple unanswered queries for this record,
7957 // then mark it to expire in five seconds if we don't get a response by then.
7958 if (cr->UnansweredQueries >= MaxUnansweredQueries)
7959 {
7960 // Only show debugging message if this record was not about to expire anyway
7961 if (RRExpireTime(cr) - m->timenow > (mDNSs32) kDefaultReconfirmTimeForNoAnswer * 4 / 3 + mDNSPlatformOneSecond)
7962 LogInfo("ProcessQuery: UnansweredQueries %lu interface %lu TTL %lu mDNS_Reconfirm() for %s",
7963 cr->UnansweredQueries, InterfaceID, (RRExpireTime(cr) - m->timenow + mDNSPlatformOneSecond-1) / mDNSPlatformOneSecond, CRDisplayString(m, cr));
7964
7965 m->mDNSStats.PoofCacheDeletions++;
7966 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
7967 }
7968 }
7969#endif // POOF_ENABLED
7970
7971 while (DupQuestions)
7972 {
7973 DNSQuestion *q = DupQuestions;
7974 DupQuestions = q->NextInDQList;
7975 q->NextInDQList = mDNSNULL;
7976 RecordDupSuppressInfo(q->DupSuppress, m->timenow, InterfaceID, srcaddr->type);
7977 debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s", q->qname.c, DNSTypeName(q->qtype), InterfaceID,
7978 srcaddr->type == mDNSAddrType_IPv4 ? "v4" : "v6");
7979 }
7980
7981 if (McastNSEC3Records)
7982 {
7983 debugf("ProcessQuery: McastNSEC3Records not used");
7984 FreeNSECRecords(m, McastNSEC3Records);
7985 }
7986
7987 return(responseptr);
7988}
7989
7990mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end,
7991 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
7992 const mDNSInterfaceID InterfaceID)
7993{
7994 mDNSu8 *responseend = mDNSNULL;
7995 mDNSBool QueryWasLocalUnicast = srcaddr && dstaddr &&
7996 !mDNSAddrIsDNSMulticast(dstaddr) && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr);
7997
7998 if (!dstaddr || (!InterfaceID && mDNSAddrIsDNSMulticast(dstaddr)))
7999 {
8000 const char *const reason = !dstaddr ? "Received over TCP connection" : "Multicast, but no InterfaceID";
8001 LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
8002 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes (%s)",
8003 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
8004 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,",
8005 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,",
8006 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,",
8007 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data, reason);
8008 return;
8009 }
8010
8011 verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
8012 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes",
8013 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
8014 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,",
8015 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,",
8016 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,",
8017 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data);
8018
8019 responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID,
8020 !mDNSSameIPPort(srcport, MulticastDNSPort), mDNSAddrIsDNSMulticast(dstaddr), QueryWasLocalUnicast, &m->omsg);
8021
8022 if (responseend) // If responseend is non-null, that means we built a unicast response packet
8023 {
8024 debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
8025 m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s",
8026 m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s",
8027 m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s",
8028 srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type);
8029 mDNSSendDNSMessage(m, &m->omsg, responseend, InterfaceID, mDNSNULL, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse);
8030 }
8031}
8032
8033#if 0
8034mDNSlocal mDNSBool TrustedSource(const mDNS *const m, const mDNSAddr *const srcaddr)
8035{
8036 DNSServer *s;
8037 (void)m; // Unused
8038 (void)srcaddr; // Unused
8039 for (s = m->DNSServers; s; s = s->next)
8040 if (mDNSSameAddress(srcaddr, &s->addr)) return(mDNStrue);
8041 return(mDNSfalse);
8042}
8043#endif
8044
8045struct UDPSocket_struct
8046{
8047 mDNSIPPort port; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port
8048};
8049
8050mDNSlocal DNSQuestion *ExpectingUnicastResponseForQuestion(const mDNS *const m, const mDNSIPPort port, const mDNSOpaque16 id, const DNSQuestion *const question, mDNSBool tcp)
8051{
8052 DNSQuestion *q;
8053 for (q = m->Questions; q; q=q->next)
8054 {
8055 if (!tcp && !q->LocalSocket) continue;
8056 if (mDNSSameIPPort(tcp ? q->tcpSrcPort : q->LocalSocket->port, port) &&
8057 mDNSSameOpaque16(q->TargetQID, id) &&
8058 q->qtype == question->qtype &&
8059 q->qclass == question->qclass &&
8060 q->qnamehash == question->qnamehash &&
8061 SameDomainName(&q->qname, &question->qname))
8062 return(q);
8063 }
8064 return(mDNSNULL);
8065}
8066
8067// This function is called when we receive a unicast response. This could be the case of a unicast response from the
8068// DNS server or a response to the QU query. Hence, the cache record's InterfaceId can be both NULL or non-NULL (QU case)
8069mDNSlocal DNSQuestion *ExpectingUnicastResponseForRecord(mDNS *const m,
8070 const mDNSAddr *const srcaddr, const mDNSBool SrcLocal, const mDNSIPPort port, const mDNSOpaque16 id, const CacheRecord *const rr, mDNSBool tcp)
8071{
8072 DNSQuestion *q;
8073 (void)id;
8074 (void)srcaddr;
8075
8076 for (q = m->Questions; q; q=q->next)
8077 {
8078 if (!q->DuplicateOf && ResourceRecordAnswersUnicastResponse(&rr->resrec, q))
8079 {
8080 if (!mDNSOpaque16IsZero(q->TargetQID))
8081 {
8082 debugf("ExpectingUnicastResponseForRecord msg->h.id %d q->TargetQID %d for %s", mDNSVal16(id), mDNSVal16(q->TargetQID), CRDisplayString(m, rr));
8083
8084 if (mDNSSameOpaque16(q->TargetQID, id))
8085 {
8086 mDNSIPPort srcp;
8087 if (!tcp)
8088 {
8089 srcp = q->LocalSocket ? q->LocalSocket->port : zeroIPPort;
8090 }
8091 else
8092 {
8093 srcp = q->tcpSrcPort;
8094 }
8095 if (mDNSSameIPPort(srcp, port)) return(q);
8096
8097 // if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue);
8098 // if (q->LongLived && mDNSSameAddress(srcaddr, &q->servAddr)) return(mDNStrue); Shouldn't need this now that we have LLQType checking
8099 // if (TrustedSource(m, srcaddr)) return(mDNStrue);
8100 LogInfo("WARNING: Ignoring suspect uDNS response for %##s (%s) [q->Target %#a:%d] from %#a:%d %s",
8101 q->qname.c, DNSTypeName(q->qtype), &q->Target, mDNSVal16(srcp), srcaddr, mDNSVal16(port), CRDisplayString(m, rr));
8102 return(mDNSNULL);
8103 }
8104 }
8105 else
8106 {
8107 if (SrcLocal && q->ExpectUnicastResp && (mDNSu32)(m->timenow - q->ExpectUnicastResp) < (mDNSu32)(mDNSPlatformOneSecond*2))
8108 return(q);
8109 }
8110 }
8111 }
8112 return(mDNSNULL);
8113}
8114
8115// Certain data types need more space for in-memory storage than their in-packet rdlength would imply
8116// Currently this applies only to rdata types containing more than one domainname,
8117// or types where the domainname is not the last item in the structure.
8118mDNSlocal mDNSu16 GetRDLengthMem(const ResourceRecord *const rr)
8119{
8120 switch (rr->rrtype)
8121 {
8122 case kDNSType_SOA: return sizeof(rdataSOA);
8123 case kDNSType_RP: return sizeof(rdataRP);
8124 case kDNSType_PX: return sizeof(rdataPX);
8125 default: return rr->rdlength;
8126 }
8127}
8128
8129mDNSexport CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg, mDNSs32 delay, mDNSBool Add, const mDNSAddr *sourceAddress)
8130{
8131 CacheRecord *rr = mDNSNULL;
8132 mDNSu16 RDLength = GetRDLengthMem(&m->rec.r.resrec);
8133
8134 if (!m->rec.r.resrec.InterfaceID) debugf("CreateNewCacheEntry %s", CRDisplayString(m, &m->rec.r));
8135
8136 //if (RDLength > InlineCacheRDSize)
8137 // LogInfo("Rdata len %4d > InlineCacheRDSize %d %s", RDLength, InlineCacheRDSize, CRDisplayString(m, &m->rec.r));
8138
8139 if (!cg) cg = GetCacheGroup(m, slot, &m->rec.r.resrec); // If we don't have a CacheGroup for this name, make one now
8140 if (cg) rr = GetCacheRecord(m, cg, RDLength); // Make a cache record, being careful not to recycle cg
8141 if (!rr) NoCacheAnswer(m, &m->rec.r);
8142 else
8143 {
8144 RData *saveptr = rr->resrec.rdata; // Save the rr->resrec.rdata pointer
8145 *rr = m->rec.r; // Block copy the CacheRecord object
8146 rr->resrec.rdata = saveptr; // Restore rr->resrec.rdata after the structure assignment
8147 rr->resrec.name = cg->name; // And set rr->resrec.name to point into our CacheGroup header
8148
8149 // We need to add the anonymous info before we call CacheRecordAdd so that
8150 // if it finds a matching question with this record, it bumps up the counters like
8151 // CurrentAnswers etc. Otherwise, when a cache entry gets removed, CacheRecordRmv
8152 // will complain.
8153 if (m->rec.r.resrec.AnonInfo)
8154 {
8155 rr->resrec.AnonInfo = m->rec.r.resrec.AnonInfo;
8156 m->rec.r.resrec.AnonInfo = mDNSNULL;
8157 }
8158 rr->DelayDelivery = delay;
8159
8160 // If this is an oversized record with external storage allocated, copy rdata to external storage
8161 if (rr->resrec.rdata == (RData*)&rr->smallrdatastorage && RDLength > InlineCacheRDSize)
8162 LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s", m->rec.r.resrec.name->c);
8163 else if (rr->resrec.rdata != (RData*)&rr->smallrdatastorage && RDLength <= InlineCacheRDSize)
8164 LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s", m->rec.r.resrec.name->c);
8165 if (RDLength > InlineCacheRDSize)
8166 mDNSPlatformMemCopy(rr->resrec.rdata, m->rec.r.resrec.rdata, sizeofRDataHeader + RDLength);
8167
8168 rr->next = mDNSNULL; // Clear 'next' pointer
8169 rr->nsec = mDNSNULL;
8170 rr->soa = mDNSNULL;
8171
8172 if (sourceAddress)
8173 rr->sourceAddress = *sourceAddress;
8174
8175 if (!rr->resrec.InterfaceID)
8176 {
8177 m->rrcache_totalused_unicast += rr->resrec.rdlength;
8178 if (DNSSECRecordType(rr->resrec.rrtype))
8179 BumpDNSSECStats(m, kStatsActionIncrement, kStatsTypeMemoryUsage, rr->resrec.rdlength);
8180 }
8181
8182 if (Add)
8183 {
8184 *(cg->rrcache_tail) = rr; // Append this record to tail of cache slot list
8185 cg->rrcache_tail = &(rr->next); // Advance tail pointer
8186 CacheRecordAdd(m, rr); // CacheRecordAdd calls SetNextCacheCheckTimeForRecord(m, rr); for us
8187 }
8188 else
8189 {
8190 // Can't use the "cg->name" if we are not adding to the cache as the
8191 // CacheGroup may be released anytime if it is empty
8192 domainname *name = mDNSPlatformMemAllocate(DomainNameLength(cg->name));
8193 if (name)
8194 {
8195 AssignDomainName(name, cg->name);
8196 rr->resrec.name = name;
8197 }
8198 else
8199 {
8200 ReleaseCacheRecord(m, rr);
8201 NoCacheAnswer(m, &m->rec.r);
8202 rr = mDNSNULL;
8203 }
8204 }
8205 }
8206 return(rr);
8207}
8208
8209mDNSlocal void RefreshCacheRecord(mDNS *const m, CacheRecord *rr, mDNSu32 ttl)
8210{
8211 rr->TimeRcvd = m->timenow;
8212 rr->resrec.rroriginalttl = ttl;
8213 rr->UnansweredQueries = 0;
8214 SetNextCacheCheckTimeForRecord(m, rr);
8215}
8216
8217mDNSexport void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease)
8218{
8219 CacheRecord *rr;
8220 CacheGroup *cg = CacheGroupForName(m, q->qnamehash, &q->qname);
8221 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
8222 if (rr->CRActiveQuestion == q)
8223 {
8224 //LogInfo("GrantCacheExtensions: new lease %d / %s", lease, CRDisplayString(m, rr));
8225 RefreshCacheRecord(m, rr, lease);
8226 }
8227}
8228
8229mDNSlocal mDNSu32 GetEffectiveTTL(const uDNS_LLQType LLQType, mDNSu32 ttl) // TTL in seconds
8230{
8231 if (LLQType == uDNS_LLQ_Entire) ttl = kLLQ_DefLease;
8232 else if (LLQType == uDNS_LLQ_Events)
8233 {
8234 // If the TTL is -1 for uDNS LLQ event packet, that means "remove"
8235 if (ttl == 0xFFFFFFFF) ttl = 0;
8236 else ttl = kLLQ_DefLease;
8237 }
8238 else // else not LLQ (standard uDNS response)
8239 {
8240 // The TTL is already capped to a maximum value in GetLargeResourceRecord, but just to be extra safe we
8241 // also do this check here to make sure we can't get overflow below when we add a quarter to the TTL
8242 if (ttl > 0x60000000UL / mDNSPlatformOneSecond) ttl = 0x60000000UL / mDNSPlatformOneSecond;
8243
8244 ttl = RRAdjustTTL(ttl);
8245
8246 // For mDNS, TTL zero means "delete this record"
8247 // For uDNS, TTL zero means: this data is true at this moment, but don't cache it.
8248 // For the sake of network efficiency, we impose a minimum effective TTL of 15 seconds.
8249 // This means that we'll do our 80, 85, 90, 95% queries at 12.00, 12.75, 13.50, 14.25 seconds
8250 // respectively, and then if we get no response, delete the record from the cache at 15 seconds.
8251 // This gives the server up to three seconds to respond between when we send our 80% query at 12 seconds
8252 // and when we delete the record at 15 seconds. Allowing cache lifetimes less than 15 seconds would
8253 // (with the current code) result in the server having even less than three seconds to respond
8254 // before we deleted the record and reported a "remove" event to any active questions.
8255 // Furthermore, with the current code, if we were to allow a TTL of less than 2 seconds
8256 // then things really break (e.g. we end up making a negative cache entry).
8257 // In the future we may want to revisit this and consider properly supporting non-cached (TTL=0) uDNS answers.
8258 if (ttl < 15) ttl = 15;
8259 }
8260
8261 return ttl;
8262}
8263
8264// When the response does not match the question directly, we still want to cache them sometimes. The current response is
8265// in m->rec.
8266mDNSlocal mDNSBool IsResponseAcceptable(mDNS *const m, const CacheRecord *crlist, DNSQuestion *q, mDNSBool *nseclist)
8267{
8268 CacheRecord *const newcr = &m->rec.r;
8269 ResourceRecord *rr = &newcr->resrec;
8270 const CacheRecord *cr;
8271
8272 *nseclist = mDNSfalse;
8273 for (cr = crlist; cr != (CacheRecord*)1; cr = cr->NextInCFList)
8274 {
8275 domainname *target = GetRRDomainNameTarget(&cr->resrec);
8276 // When we issue a query for A record, the response might contain both a CNAME and A records. Only the CNAME would
8277 // match the question and we already created a cache entry in the previous pass of this loop. Now when we process
8278 // the A record, it does not match the question because the record name here is the CNAME. Hence we try to
8279 // match with the previous records to make it an AcceptableResponse. We have to be careful about setting the
8280 // DNSServer value that we got in the previous pass. This can happen for other record types like SRV also.
8281
8282 if (target && cr->resrec.rdatahash == rr->namehash && SameDomainName(target, rr->name))
8283 {
8284 LogInfo("IsResponseAcceptable: Found a matching entry for %##s in the CacheFlushRecords %s", rr->name->c, CRDisplayString(m, cr));
8285 return (mDNStrue);
8286 }
8287 }
8288
8289 // Either the question requires validation or we are validating a response with DNSSEC in which case
8290 // we need to accept the RRSIGs also so that we can validate the response. It is also possible that
8291 // we receive NSECs for our query which does not match the qname and we need to cache in that case
8292 // too. nseclist is set if they have to be cached as part of the negative cache record.
8293 if (q && DNSSECQuestion(q))
8294 {
8295 mDNSBool same = SameDomainName(&q->qname, rr->name);
8296 if (same && (q->qtype == rr->rrtype || rr->rrtype == kDNSType_CNAME))
8297 {
8298 LogInfo("IsResponseAcceptable: Accepting, same name and qtype %s, CR %s", DNSTypeName(q->qtype),
8299 CRDisplayString(m, newcr));
8300 return mDNStrue;
8301 }
8302 // We cache RRSIGS if it covers the question type or NSEC. If it covers a NSEC,
8303 // "nseclist" is set
8304 if (rr->rrtype == kDNSType_RRSIG)
8305 {
8306 RDataBody2 *const rdb = (RDataBody2 *)newcr->smallrdatastorage.data;
8307 rdataRRSig *rrsig = &rdb->rrsig;
8308 mDNSu16 typeCovered = swap16(rrsig->typeCovered);
8309
8310 // Note the ordering. If we are looking up the NSEC record, then the RRSIG's typeCovered
8311 // would match the qtype and they are cached normally as they are not used to prove the
8312 // non-existence of any name. In that case, it is like any other normal dnssec validation
8313 // and hence nseclist should not be set.
8314
8315 if (same && ((typeCovered == q->qtype) || (typeCovered == kDNSType_CNAME)))
8316 {
8317 LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches question type %s", CRDisplayString(m, newcr),
8318 DNSTypeName(q->qtype));
8319 return mDNStrue;
8320 }
8321 else if (typeCovered == kDNSType_NSEC || typeCovered == kDNSType_NSEC3)
8322 {
8323 LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches %s type (nseclist = 1)", CRDisplayString(m, newcr), DNSTypeName(typeCovered));
8324 *nseclist = mDNStrue;
8325 return mDNStrue;
8326 }
8327 else if (typeCovered == kDNSType_SOA)
8328 {
8329 LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches SOA type (nseclist = 1)", CRDisplayString(m, newcr));
8330 *nseclist = mDNStrue;
8331 return mDNStrue;
8332 }
8333 else return mDNSfalse;
8334 }
8335 if (rr->rrtype == kDNSType_NSEC)
8336 {
8337 if (!UNICAST_NSEC(rr))
8338 {
8339 LogMsg("IsResponseAcceptable: ERROR!! Not a unicast NSEC %s", CRDisplayString(m, newcr));
8340 return mDNSfalse;
8341 }
8342 LogInfo("IsResponseAcceptable: Accepting NSEC %s (nseclist = 1)", CRDisplayString(m, newcr));
8343 *nseclist = mDNStrue;
8344 return mDNStrue;
8345 }
8346 if (rr->rrtype == kDNSType_SOA)
8347 {
8348 LogInfo("IsResponseAcceptable: Accepting SOA %s (nseclist = 1)", CRDisplayString(m, newcr));
8349 *nseclist = mDNStrue;
8350 return mDNStrue;
8351 }
8352 else if (rr->rrtype == kDNSType_NSEC3)
8353 {
8354 LogInfo("IsResponseAcceptable: Accepting NSEC3 %s (nseclist = 1)", CRDisplayString(m, newcr));
8355 *nseclist = mDNStrue;
8356 return mDNStrue;
8357 }
8358 }
8359 return mDNSfalse;
8360}
8361
8362mDNSlocal void FreeNSECRecords(mDNS *const m, CacheRecord *NSECRecords)
8363{
8364 CacheRecord *rp, *next;
8365
8366 for (rp = NSECRecords; rp; rp = next)
8367 {
8368 next = rp->next;
8369 ReleaseCacheRecord(m, rp);
8370 }
8371}
8372
8373// If we received zero DNSSEC records even when the DO/EDNS0 bit was set, we need to provide this
8374// information to ValidatingResponse question to indicate the DNSSEC status to the application
8375mDNSlocal void mDNSCoreReceiveNoDNSSECAnswers(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *dstaddr,
8376 mDNSIPPort dstport, const mDNSInterfaceID InterfaceID)
8377{
8378 int i;
8379 const mDNSu8 *ptr = response->data;
8380
8381 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
8382 {
8383 DNSQuestion pktq;
8384 DNSQuestion *qptr = mDNSNULL;
8385 ptr = getQuestion(response, ptr, end, InterfaceID, &pktq);
8386 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &pktq, !dstaddr)) &&
8387 qptr->ValidatingResponse)
8388 {
8389 DNSQuestion *next, *q;
8390
8391 if (qptr->DuplicateOf)
8392 LogMsg("mDNSCoreReceiveNoDNSSECAnswers: ERROR!! qptr %##s (%s) Duplicate question matching response", qptr->qname.c, DNSTypeName(qptr->qtype));
8393
8394 // Be careful to call the callback for duplicate questions first and then the original
8395 // question. If we called the callback on the original question, it could stop and
8396 // a duplicate question would become the original question.
8397 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls
8398 for (q = qptr->next ; q && q != m->NewQuestions; q = next)
8399 {
8400 next = q->next;
8401 if (q->DuplicateOf == qptr)
8402 {
8403 if (q->ValidatingResponse)
8404 LogInfo("mDNSCoreReceiveNoDNSSECAnswers: qptr %##s (%s) Duplicate question found", q->qname.c, DNSTypeName(q->qtype));
8405 else
8406 LogMsg("mDNSCoreReceiveNoDNSSECAnswers: ERROR!! qptr %##s (%s) Duplicate question not ValidatingResponse", q->qname.c, DNSTypeName(q->qtype));
8407 if (q->QuestionCallback)
8408 q->QuestionCallback(m, q, mDNSNULL, QC_nodnssec);
8409 }
8410 }
8411 if (qptr->QuestionCallback)
8412 qptr->QuestionCallback(m, qptr, mDNSNULL, QC_nodnssec);
8413 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
8414 }
8415 }
8416}
8417
8418mDNSlocal void mDNSCoreReceiveNoUnicastAnswers(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *dstaddr,
8419 mDNSIPPort dstport, const mDNSInterfaceID InterfaceID, uDNS_LLQType LLQType, mDNSu8 rcode, CacheRecord *NSECRecords)
8420{
8421 int i;
8422 const mDNSu8 *ptr = response->data;
8423 CacheRecord *SOARecord = mDNSNULL;
8424
8425 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
8426 {
8427 DNSQuestion q;
8428 DNSQuestion *qptr = mDNSNULL;
8429 ptr = getQuestion(response, ptr, end, InterfaceID, &q);
8430 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr)))
8431 {
8432 CacheRecord *rr, *neg = mDNSNULL;
8433 CacheGroup *cg = CacheGroupForName(m, q.qnamehash, &q.qname);
8434 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
8435 if (SameNameRecordAnswersQuestion(&rr->resrec, qptr))
8436 {
8437 // 1. If we got a fresh answer to this query, then don't need to generate a negative entry
8438 if (RRExpireTime(rr) - m->timenow > 0) break;
8439 // 2. If we already had a negative entry, keep track of it so we can resurrect it instead of creating a new one
8440 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) neg = rr;
8441 }
8442 // When we're doing parallel unicast and multicast queries for dot-local names (for supporting Microsoft
8443 // Active Directory sites) we don't want to waste memory making negative cache entries for all the unicast answers.
8444 // Otherwise we just fill up our cache with negative entries for just about every single multicast name we ever look up
8445 // (since the Microsoft Active Directory server is going to assert that pretty much every single multicast name doesn't exist).
8446 // This is not only a waste of memory, but there's also the problem of those negative entries confusing us later -- e.g. we
8447 // suppress sending our mDNS query packet because we think we already have a valid (negative) answer to that query in our cache.
8448 // The one exception is that we *DO* want to make a negative cache entry for "local. SOA", for the (common) case where we're
8449 // *not* on a Microsoft Active Directory network, and there is no authoritative server for "local". Note that this is not
8450 // in conflict with the mDNS spec, because that spec says, "Multicast DNS Zones have no SOA record," so it's okay to cache
8451 // negative answers for "local. SOA" from a uDNS server, because the mDNS spec already says that such records do not exist :-)
8452 //
8453 // By suppressing negative responses, it might take longer to timeout a .local question as it might be expecting a
8454 // response e.g., we deliver a positive "A" response and suppress negative "AAAA" response and the upper layer may
8455 // be waiting longer to get the AAAA response before returning the "A" response to the application. To handle this
8456 // case without creating the negative cache entries, we generate a negative response and let the layer above us
8457 // do the appropriate thing. This negative response is also needed for appending new search domains.
8458 if (!InterfaceID && q.qtype != kDNSType_SOA && IsLocalDomain(&q.qname))
8459 {
8460 if (!rr)
8461 {
8462 LogInfo("mDNSCoreReceiveNoUnicastAnswers: Generate negative response for %##s (%s)", q.qname.c, DNSTypeName(q.qtype));
8463 m->CurrentQuestion = qptr;
8464 // We are not creating a cache record in this case, we need to pass back
8465 // the error we got so that the proxy code can return the right one to
8466 // the application
8467 if (qptr->ProxyQuestion)
8468 qptr->responseFlags = response->h.flags;
8469 GenerateNegativeResponse(m, mDNSInterface_Any, QC_forceresponse);
8470 m->CurrentQuestion = mDNSNULL;
8471 }
8472 else
8473 {
8474 LogInfo("mDNSCoreReceiveNoUnicastAnswers: Skipping check and not creating a negative cache entry for %##s (%s)", q.qname.c, DNSTypeName(q.qtype));
8475 }
8476 }
8477 else
8478 {
8479 if (!rr)
8480 {
8481 // We start off assuming a negative caching TTL of 60 seconds
8482 // but then look to see if we can find an SOA authority record to tell us a better value we should be using
8483 mDNSu32 negttl = 60;
8484 int repeat = 0;
8485 const domainname *name = &q.qname;
8486 mDNSu32 hash = q.qnamehash;
8487
8488 // Special case for our special Microsoft Active Directory "local SOA" check.
8489 // Some cheap home gateways don't include an SOA record in the authority section when
8490 // they send negative responses, so we don't know how long to cache the negative result.
8491 // Because we don't want to keep hitting the root name servers with our query to find
8492 // if we're on a network using Microsoft Active Directory using "local" as a private
8493 // internal top-level domain, we make sure to cache the negative result for at least one day.
8494 if (q.qtype == kDNSType_SOA && SameDomainName(&q.qname, &localdomain)) negttl = 60 * 60 * 24;
8495
8496 // If we're going to make (or update) a negative entry, then look for the appropriate TTL from the SOA record
8497 if (response->h.numAuthorities && (ptr = LocateAuthorities(response, end)) != mDNSNULL)
8498 {
8499 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
8500 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_SOA)
8501 {
8502 CacheGroup *cgSOA = CacheGroupForRecord(m, &m->rec.r.resrec);
8503 const rdataSOA *const soa = (const rdataSOA *)m->rec.r.resrec.rdata->u.data;
8504 mDNSu32 ttl_s = soa->min;
8505 // We use the lesser of the SOA.MIN field and the SOA record's TTL, *except*
8506 // for the SOA record for ".", where the record is reported as non-cacheable
8507 // (TTL zero) for some reason, so in this case we just take the SOA record's TTL as-is
8508 if (ttl_s > m->rec.r.resrec.rroriginalttl && m->rec.r.resrec.name->c[0])
8509 ttl_s = m->rec.r.resrec.rroriginalttl;
8510 if (negttl < ttl_s) negttl = ttl_s;
8511
8512 // Create the SOA record as we may have to return this to the questions
8513 // that we are acting as a proxy for currently or in the future.
8514 SOARecord = CreateNewCacheEntry(m, HashSlotFromNameHash(m->rec.r.resrec.namehash), cgSOA, 1, mDNSfalse, mDNSNULL);
8515
8516 // Special check for SOA queries: If we queried for a.b.c.d.com, and got no answer,
8517 // with an Authority Section SOA record for d.com, then this is a hint that the authority
8518 // is d.com, and consequently SOA records b.c.d.com and c.d.com don't exist either.
8519 // To do this we set the repeat count so the while loop below will make a series of negative cache entries for us
8520 //
8521 // For ProxyQuestions, we don't do this as we need to create additional SOA records to cache them
8522 // along with the negative cache record. For simplicity, we don't create the additional records.
8523 if (!qptr->ProxyQuestion && q.qtype == kDNSType_SOA)
8524 {
8525 int qcount = CountLabels(&q.qname);
8526 int scount = CountLabels(m->rec.r.resrec.name);
8527 if (qcount - 1 > scount)
8528 if (SameDomainName(SkipLeadingLabels(&q.qname, qcount - scount), m->rec.r.resrec.name))
8529 repeat = qcount - 1 - scount;
8530 }
8531 }
8532 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
8533 }
8534
8535 // If we already had a negative entry in the cache, then we double our existing negative TTL. This is to avoid
8536 // the case where the record doesn't exist (e.g. particularly for things like our lb._dns-sd._udp.<domain> query),
8537 // and the server returns no SOA record (or an SOA record with a small MIN TTL) so we assume a TTL
8538 // of 60 seconds, and we end up polling the server every minute for a record that doesn't exist.
8539 // With this fix in place, when this happens, we double the effective TTL each time (up to one hour),
8540 // so that we back off our polling rate and don't keep hitting the server continually.
8541 if (neg)
8542 {
8543 if (negttl < neg->resrec.rroriginalttl * 2)
8544 negttl = neg->resrec.rroriginalttl * 2;
8545 if (negttl > 3600)
8546 negttl = 3600;
8547 }
8548
8549 negttl = GetEffectiveTTL(LLQType, negttl); // Add 25% grace period if necessary
8550
8551 // If we already had a negative cache entry just update it, else make one or more new negative cache entries.
8552 if (neg)
8553 {
8554 LogInfo("mDNSCoreReceiveNoUnicastAnswers: Renewing negative TTL from %d to %d %s", neg->resrec.rroriginalttl, negttl, CRDisplayString(m, neg));
8555 RefreshCacheRecord(m, neg, negttl);
8556 // When we created the cache for the first time and answered the question, the question's
8557 // interval was set to MaxQuestionInterval. If the cache is about to expire and we are resending
8558 // the queries, the interval should still be at MaxQuestionInterval. If the query is being
8559 // restarted (setting it to InitialQuestionInterval) for other reasons e.g., wakeup,
8560 // we should reset its question interval here to MaxQuestionInterval.
8561 ResetQuestionState(m, qptr);
8562 if (DNSSECQuestion(qptr))
8563 neg->CRDNSSECQuestion = 1;
8564 // Update the NSEC records again.
8565 // TBD: Need to purge and revalidate if the cached NSECS and the new set are not same.
8566 if (NSECRecords)
8567 {
8568 if (!AddNSECSForCacheRecord(m, NSECRecords, neg, rcode))
8569 {
8570 // We might just have an SOA record for zones that are not signed and hence don't log
8571 // this as an error
8572 LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord failed to add NSEC for negcr %s during refresh", CRDisplayString(m, neg));
8573 FreeNSECRecords(m, NSECRecords);
8574 neg->CRDNSSECQuestion = 0;
8575 }
8576 NSECRecords = mDNSNULL;
8577 }
8578 if (SOARecord)
8579 {
8580 if (neg->soa)
8581 ReleaseCacheRecord(m, neg->soa);
8582 neg->soa = SOARecord;
8583 SOARecord = mDNSNULL;
8584 }
8585 }
8586 else while (1)
8587 {
8588 CacheRecord *negcr;
8589 debugf("mDNSCoreReceiveNoUnicastAnswers making negative cache entry TTL %d for %##s (%s)", negttl, name->c, DNSTypeName(q.qtype));
8590 MakeNegativeCacheRecord(m, &m->rec.r, name, hash, q.qtype, q.qclass, negttl, mDNSInterface_Any, qptr->qDNSServer);
8591 m->rec.r.responseFlags = response->h.flags;
8592 // We create SOA records above which might create new cache groups. Earlier
8593 // in the function we looked up the cache group for the name and it could have
8594 // been NULL. If we pass NULL cg to new cache entries that we create below,
8595 // it will create additional cache groups for the same name. To avoid that,
8596 // look up the cache group again to re-initialize cg again.
8597 cg = CacheGroupForName(m, hash, name);
8598 if (NSECRecords && DNSSECQuestion(qptr))
8599 {
8600 // Create the cache entry with delay and then add the NSEC records
8601 // to it and add it immediately.
8602 negcr = CreateNewCacheEntry(m, HashSlotFromNameHash(hash), cg, 1, mDNStrue, mDNSNULL);
8603 if (negcr)
8604 {
8605 negcr->CRDNSSECQuestion = 0;
8606 if (!AddNSECSForCacheRecord(m, NSECRecords, negcr, rcode))
8607 {
8608 LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord failed to add NSEC for negcr %s",
8609 CRDisplayString(m, negcr));
8610 FreeNSECRecords(m, NSECRecords);
8611 }
8612 else
8613 {
8614 negcr->CRDNSSECQuestion = 1;
8615 LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord added neg NSEC for %s", CRDisplayString(m, negcr));
8616 }
8617 NSECRecords = mDNSNULL;
8618 negcr->DelayDelivery = 0;
8619 CacheRecordDeferredAdd(m, negcr);
8620 }
8621 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
8622 break;
8623 }
8624 else
8625 {
8626 // Need to add with a delay so that we can tag the SOA record
8627 negcr = CreateNewCacheEntry(m, HashSlotFromNameHash(hash), cg, 1, mDNStrue, mDNSNULL);
8628 if (negcr)
8629 {
8630 negcr->CRDNSSECQuestion = 0;
8631 if (DNSSECQuestion(qptr))
8632 negcr->CRDNSSECQuestion = 1;
8633 negcr->DelayDelivery = 0;
8634
8635 if (SOARecord)
8636 {
8637 if (negcr->soa)
8638 ReleaseCacheRecord(m, negcr->soa);
8639 negcr->soa = SOARecord;
8640 SOARecord = mDNSNULL;
8641 }
8642 CacheRecordDeferredAdd(m, negcr);
8643 }
8644 }
8645 m->rec.r.responseFlags = zeroID;
8646 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
8647 if (!repeat) break;
8648 repeat--;
8649 name = (const domainname *)(name->c + 1 + name->c[0]);
8650 hash = DomainNameHashValue(name);
8651 }
8652 }
8653 }
8654 }
8655 }
8656 if (NSECRecords) { LogInfo("mDNSCoreReceiveNoUnicastAnswers: NSECRecords not used"); FreeNSECRecords(m, NSECRecords); }
8657 if (SOARecord) { LogInfo("mDNSCoreReceiveNoUnicastAnswers: SOARecord not used"); ReleaseCacheRecord(m, SOARecord); }
8658}
8659
8660mDNSlocal void mDNSCorePrintStoredProxyRecords(mDNS *const m)
8661{
8662 AuthRecord *rrPtr = mDNSNULL;
8663 LogSPS("Stored Proxy records :");
8664 for (rrPtr = m->SPSRRSet; rrPtr; rrPtr = rrPtr->next)
8665 {
8666 LogSPS("%s", ARDisplayString(m, rrPtr));
8667 }
8668}
8669
8670mDNSlocal mDNSBool mDNSCoreRegisteredProxyRecord(mDNS *const m, AuthRecord *rr)
8671{
8672 AuthRecord *rrPtr = mDNSNULL;
8673
8674 for (rrPtr = m->SPSRRSet; rrPtr; rrPtr = rrPtr->next)
8675 {
8676 if (IdenticalResourceRecord(&rrPtr->resrec, &rr->resrec))
8677 {
8678 LogSPS("mDNSCoreRegisteredProxyRecord: Ignoring packet registered with sleep proxy : %s ", ARDisplayString(m, rr));
8679 return mDNStrue;
8680 }
8681 }
8682 mDNSCorePrintStoredProxyRecords(m);
8683 return mDNSfalse;
8684}
8685
8686mDNSlocal CacheRecord* mDNSCoreReceiveCacheCheck(mDNS *const m, const DNSMessage *const response, uDNS_LLQType LLQType,
8687 const mDNSu32 slot, CacheGroup *cg, DNSQuestion *unicastQuestion, CacheRecord ***cfp, CacheRecord **NSECCachePtr,
8688 mDNSInterfaceID InterfaceID)
8689{
8690 CacheRecord *rr;
8691 CacheRecord **cflocal = *cfp;
8692
8693 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
8694 {
8695 mDNSBool match;
8696 // Resource record received via unicast, the resGroupID should match ?
8697 if (!InterfaceID)
8698 {
8699 mDNSu16 id1 = (rr->resrec.rDNSServer ? rr->resrec.rDNSServer->resGroupID : 0);
8700 mDNSu16 id2 = (m->rec.r.resrec.rDNSServer ? m->rec.r.resrec.rDNSServer->resGroupID : 0);
8701 match = (id1 == id2);
8702 }
8703 else
8704 match = (rr->resrec.InterfaceID == InterfaceID);
8705 // If we found this exact resource record, refresh its TTL
8706 if (match && IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec))
8707 {
8708 if (m->rec.r.resrec.rdlength > InlineCacheRDSize)
8709 verbosedebugf("mDNSCoreReceiveCacheCheck: Found record size %5d interface %p already in cache: %s",
8710 m->rec.r.resrec.rdlength, InterfaceID, CRDisplayString(m, &m->rec.r));
8711
8712 if (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask)
8713 {
8714 // If this packet record has the kDNSClass_UniqueRRSet flag set, then add it to our cache flushing list
8715 if (rr->NextInCFList == mDNSNULL && *cfp != &rr->NextInCFList && LLQType != uDNS_LLQ_Events)
8716 {
8717 *cflocal = rr;
8718 cflocal = &rr->NextInCFList;
8719 *cflocal = (CacheRecord*)1;
8720 *cfp = &rr->NextInCFList;
8721 }
8722
8723 // If this packet record is marked unique, and our previous cached copy was not, then fix it
8724 if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))
8725 {
8726 DNSQuestion *q;
8727 for (q = m->Questions; q; q=q->next)
8728 {
8729 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
8730 q->UniqueAnswers++;
8731 }
8732 rr->resrec.RecordType = m->rec.r.resrec.RecordType;
8733 }
8734 }
8735
8736 if (!SameRDataBody(&m->rec.r.resrec, &rr->resrec.rdata->u, SameDomainNameCS))
8737 {
8738 // If the rdata of the packet record differs in name capitalization from the record in our cache
8739 // then mDNSPlatformMemSame will detect this. In this case, throw the old record away, so that clients get
8740 // a 'remove' event for the record with the old capitalization, and then an 'add' event for the new one.
8741 // <rdar://problem/4015377> mDNS -F returns the same domain multiple times with different casing
8742 rr->resrec.rroriginalttl = 0;
8743 rr->TimeRcvd = m->timenow;
8744 rr->UnansweredQueries = MaxUnansweredQueries;
8745 SetNextCacheCheckTimeForRecord(m, rr);
8746 LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change old: %s", CRDisplayString(m, rr));
8747 LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change new: %s", CRDisplayString(m, &m->rec.r));
8748 LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change in %d slot %3d in %d %d",
8749 NextCacheCheckEvent(rr) - m->timenow, slot, m->rrcache_nextcheck[slot] - m->timenow, m->NextCacheCheck - m->timenow);
8750 // DO NOT break out here -- we want to continue as if we never found it
8751 }
8752 else if (!IdenticalAnonInfo(m->rec.r.resrec.AnonInfo, rr->resrec.AnonInfo))
8753 {
8754 // If the NSEC3 record changed, a few possibilities
8755 //
8756 // 1) the peer reinitialized e.g., after network change and still part of the
8757 // same set.
8758 // 2) the peer went to a different set but we did not see the goodbyes. If we just
8759 // update the nsec3 record, it would be incorrect. Flush the cache so that we
8760 // can deliver a RMV followed by ADD.
8761 // 3) if the peer is ourselves and we see the goodbye when moving to a different set
8762 // and so we flush the cache and create a new cache record with the new set information.
8763 // Now we move back to the original set. In this case, we can't just update the
8764 // NSEC3 record alone. We need to flush so that we can deliver an RMV followed by ADD
8765 // when we create the new cache entry.
8766 //
8767 // Note: For case (1), we could avoid flushing the cache but we can't tell the difference
8768 // from the other cases.
8769 rr->resrec.rroriginalttl = 0;
8770 rr->TimeRcvd = m->timenow;
8771 rr->UnansweredQueries = MaxUnansweredQueries;
8772 SetNextCacheCheckTimeForRecord(m, rr);
8773 LogInfo("mDNSCoreReceiveCacheCheck: AnonInfo changed for %s", CRDisplayString(m, rr));
8774 // DO NOT break out here -- we want to continue as if we never found it. When we return
8775 // from this function, we will create a new cache entry with the new NSEC3 record
8776 }
8777 else if (m->rec.r.resrec.rroriginalttl > 0)
8778 {
8779 DNSQuestion *q;
8780
8781 m->mDNSStats.CacheRefreshed++;
8782
8783 if (rr->resrec.rroriginalttl == 0) debugf("uDNS rescuing %s", CRDisplayString(m, rr));
8784 RefreshCacheRecord(m, rr, m->rec.r.resrec.rroriginalttl);
8785 rr->responseFlags = response->h.flags;
8786
8787 // If we may have NSEC records returned with the answer (which we don't know yet as it
8788 // has not been processed), we need to cache them along with the first cache
8789 // record in the list that answers the question so that it can be used for validation
8790 // later. The "type" check below is to make sure that we cache on the cache record
8791 // that would answer the question. It is possible that we might cache additional things
8792 // e.g., MX question might cache A records also, and we want to cache the NSEC on
8793 // the record that answers the question.
8794 if (response->h.numAnswers && unicastQuestion && unicastQuestion->qtype == rr->resrec.rrtype
8795 && !(*NSECCachePtr))
8796 {
8797 LogInfo("mDNSCoreReceiveCacheCheck: rescuing RR %s", CRDisplayString(m, rr));
8798 *NSECCachePtr = rr;
8799 }
8800 // We have to reset the question interval to MaxQuestionInterval so that we don't keep
8801 // polling the network once we get a valid response back. For the first time when a new
8802 // cache entry is created, AnswerCurrentQuestionWithResourceRecord does that.
8803 // Subsequently, if we reissue questions from within the mDNSResponder e.g., DNS server
8804 // configuration changed, without flushing the cache, we reset the question interval here.
8805 // Currently, we do this for for both multicast and unicast questions as long as the record
8806 // type is unique. For unicast, resource record is always unique and for multicast it is
8807 // true for records like A etc. but not for PTR.
8808 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)
8809 {
8810 for (q = m->Questions; q; q=q->next)
8811 {
8812 if (!q->DuplicateOf && !q->LongLived &&
8813 ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q))
8814 {
8815 ResetQuestionState(m, q);
8816 debugf("mDNSCoreReceiveCacheCheck: Set MaxQuestionInterval for %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
8817 break; // Why break here? Aren't there other questions we might want to look at?-- SC July 2010
8818 }
8819 }
8820 }
8821 break;
8822 }
8823 else
8824 {
8825 // If the packet TTL is zero, that means we're deleting this record.
8826 // To give other hosts on the network a chance to protest, we push the deletion
8827 // out one second into the future. Also, we set UnansweredQueries to MaxUnansweredQueries.
8828 // Otherwise, we'll do final queries for this record at 80% and 90% of its apparent
8829 // lifetime (800ms and 900ms from now) which is a pointless waste of network bandwidth.
8830 // If record's current expiry time is more than a second from now, we set it to expire in one second.
8831 // If the record is already going to expire in less than one second anyway, we leave it alone --
8832 // we don't want to let the goodbye packet *extend* the record's lifetime in our cache.
8833 debugf("DE for %s", CRDisplayString(m, rr));
8834 if (RRExpireTime(rr) - m->timenow > mDNSPlatformOneSecond)
8835 {
8836 rr->resrec.rroriginalttl = 1;
8837 rr->TimeRcvd = m->timenow;
8838 rr->UnansweredQueries = MaxUnansweredQueries;
8839 SetNextCacheCheckTimeForRecord(m, rr);
8840 }
8841 break;
8842 }
8843 }
8844 }
8845 return rr;
8846}
8847
8848mDNSlocal void mDNSParseNSEC3Records(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end,
8849 const mDNSInterfaceID InterfaceID, CacheRecord **NSEC3Records)
8850{
8851 const mDNSu8 *ptr;
8852 CacheRecord *rr;
8853 int i;
8854
8855 if (!response->h.numAuthorities)
8856 return;
8857 ptr = LocateAuthorities(response, end);
8858 if (!ptr)
8859 {
8860 LogInfo("mDNSParseNSEC3Records: ERROR can't locate authorities");
8861 return;
8862 }
8863 for (i = 0; i < response->h.numAuthorities && ptr && ptr < end; i++)
8864 {
8865 CacheGroup *cg;
8866
8867 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
8868 if (!ptr || m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative || m->rec.r.resrec.rrtype != kDNSType_NSEC3)
8869 {
8870 debugf("mDNSParseNSEC3Records: ptr %p, Record %s, ignoring", ptr, CRDisplayString(m, &m->rec.r));
8871 m->rec.r.resrec.RecordType = 0;
8872 continue;
8873 }
8874 cg = CacheGroupForRecord(m, &m->rec.r.resrec);
8875 // Create the cache entry but don't add it to the cache it. We need
8876 // to cache this along with the main cache record.
8877 rr = CreateNewCacheEntry(m, HashSlotFromNameHash(m->rec.r.resrec.namehash), cg, 0, mDNSfalse, mDNSNULL);
8878 if (rr)
8879 {
8880 debugf("mDNSParseNSEC3Records: %s", CRDisplayString(m, rr));
8881 *NSEC3Records = rr;
8882 NSEC3Records = &rr->next;
8883 }
8884 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
8885 }
8886}
8887
8888mDNSlocal void mDNSCoreResetRecord(mDNS *const m)
8889{
8890 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
8891 if (m->rec.r.resrec.AnonInfo)
8892 {
8893 FreeAnonInfo(m->rec.r.resrec.AnonInfo);
8894 m->rec.r.resrec.AnonInfo = mDNSNULL;
8895 }
8896}
8897
8898// Note: mDNSCoreReceiveResponse calls mDNS_Deregister_internal which can call a user callback, which may change
8899// the record list and/or question list.
8900// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
8901// InterfaceID non-NULL tells us the interface this multicast response was received on
8902// InterfaceID NULL tells us this was a unicast response
8903// dstaddr NULL tells us we received this over an outgoing TCP connection we made
8904mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m,
8905 const DNSMessage *const response, const mDNSu8 *end,
8906 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
8907 const mDNSInterfaceID InterfaceID)
8908{
8909 int i;
8910 mDNSBool ResponseMCast = dstaddr && mDNSAddrIsDNSMulticast(dstaddr);
8911 mDNSBool ResponseSrcLocal = !srcaddr || mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr);
8912 DNSQuestion *llqMatch = mDNSNULL;
8913 DNSQuestion *unicastQuestion = mDNSNULL;
8914 uDNS_LLQType LLQType = uDNS_recvLLQResponse(m, response, end, srcaddr, srcport, &llqMatch);
8915
8916 // "(CacheRecord*)1" is a special (non-zero) end-of-list marker
8917 // We use this non-zero marker so that records in our CacheFlushRecords list will always have NextInCFList
8918 // set non-zero, and that tells GetCacheEntity() that they're not, at this moment, eligible for recycling.
8919 CacheRecord *CacheFlushRecords = (CacheRecord*)1;
8920 CacheRecord **cfp = &CacheFlushRecords;
8921 CacheRecord *NSECRecords = mDNSNULL;
8922 CacheRecord *NSECCachePtr = mDNSNULL;
8923 CacheRecord **nsecp = &NSECRecords;
8924 CacheRecord *McastNSEC3Records = mDNSNULL;
8925 mDNSBool nseclist;
8926 mDNSu8 rcode = '\0';
8927 mDNSBool rrsigsCreated = mDNSfalse;
8928 mDNSBool DNSSECQuestion = mDNSfalse;
8929 NetworkInterfaceInfo *llintf = FirstIPv4LLInterfaceForID(m, InterfaceID);
8930 mDNSBool recordAcceptedInResponse = mDNSfalse; // Set if a record is accepted from a unicast mDNS response that answers an existing question.
8931
8932 // All records in a DNS response packet are treated as equally valid statements of truth. If we want
8933 // to guard against spoof responses, then the only credible protection against that is cryptographic
8934 // security, e.g. DNSSEC., not worrying about which section in the spoof packet contained the record.
8935 int firstauthority = response->h.numAnswers;
8936 int firstadditional = firstauthority + response->h.numAuthorities;
8937 int totalrecords = firstadditional + response->h.numAdditionals;
8938 const mDNSu8 *ptr = response->data;
8939 DNSServer *uDNSServer = mDNSNULL;
8940
8941 debugf("Received Response from %#-15a addressed to %#-15a on %p with "
8942 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes LLQType %d",
8943 srcaddr, dstaddr, InterfaceID,
8944 response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,",
8945 response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
8946 response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
8947 response->h.numAdditionals, response->h.numAdditionals == 1 ? " " : "s", end - response->data, LLQType);
8948
8949#if AWD_METRICS
8950 if (mDNSSameIPPort(srcport, UnicastDNSPort))
8951 {
8952 MetricsUpdateDNSResponseSize((mDNSu32)(end - (mDNSu8 *)response));
8953 }
8954#endif
8955
8956 // According to RFC 2181 <http://www.ietf.org/rfc/rfc2181.txt>
8957 // When a DNS client receives a reply with TC
8958 // set, it should ignore that response, and query again, using a
8959 // mechanism, such as a TCP connection, that will permit larger replies.
8960 // It feels wrong to be throwing away data after the network went to all the trouble of delivering it to us, but
8961 // delivering some records of the RRSet first and then the remainder a couple of milliseconds later was causing
8962 // failures in our Microsoft Active Directory client, which expects to get the entire set of answers at once.
8963 // <rdar://problem/6690034> Can't bind to Active Directory
8964 // In addition, if the client immediately canceled its query after getting the initial partial response, then we'll
8965 // abort our TCP connection, and not complete the operation, and end up with an incomplete RRSet in our cache.
8966 // Next time there's a query for this RRSet we'll see answers in our cache, and assume we have the whole RRSet already,
8967 // and not even do the TCP query.
8968 // Accordingly, if we get a uDNS reply with kDNSFlag0_TC set, we bail out and wait for the TCP response containing the entire RRSet.
8969 if (!InterfaceID && (response->h.flags.b[0] & kDNSFlag0_TC)) return;
8970
8971 if (LLQType == uDNS_LLQ_Ignore) return;
8972
8973 // 1. We ignore questions (if any) in mDNS response packets
8974 // 2. If this is an LLQ response, we handle it much the same
8975 // 3. If we get a uDNS UDP response with the TC (truncated) bit set, then we can't treat this
8976 // answer as being the authoritative complete RRSet, and respond by deleting all other
8977 // matching cache records that don't appear in this packet.
8978 // Otherwise, this is a authoritative uDNS answer, so arrange for any stale records to be purged
8979 if (ResponseMCast || LLQType == uDNS_LLQ_Events || (response->h.flags.b[0] & kDNSFlag0_TC))
8980 ptr = LocateAnswers(response, end);
8981 // Otherwise, for one-shot queries, any answers in our cache that are not also contained
8982 // in this response packet are immediately deemed to be invalid.
8983 else
8984 {
8985 mDNSBool failure, returnEarly;
8986 rcode = (mDNSu8)(response->h.flags.b[1] & kDNSFlag1_RC_Mask);
8987 failure = !(rcode == kDNSFlag1_RC_NoErr || rcode == kDNSFlag1_RC_NXDomain || rcode == kDNSFlag1_RC_NotAuth);
8988 returnEarly = mDNSfalse;
8989 // We could possibly combine this with the similar loop at the end of this function --
8990 // instead of tagging cache records here and then rescuing them if we find them in the answer section,
8991 // we could instead use the "m->PktNum" mechanism to tag each cache record with the packet number in
8992 // which it was received (or refreshed), and then at the end if we find any cache records which
8993 // answer questions in this packet's question section, but which aren't tagged with this packet's
8994 // packet number, then we deduce they are old and delete them
8995 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
8996 {
8997 DNSQuestion q, *qptr = mDNSNULL;
8998 ptr = getQuestion(response, ptr, end, InterfaceID, &q);
8999 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr)))
9000 {
9001 if (!failure)
9002 {
9003 CacheRecord *rr;
9004 // Remember the unicast question that we found, which we use to make caching
9005 // decisions later on in this function
9006 CacheGroup *cg = CacheGroupForName(m, q.qnamehash, &q.qname);
9007 if (!mDNSOpaque16IsZero(response->h.id))
9008 {
9009 unicastQuestion = qptr;
9010 if (qptr->qDNSServer && DNSSECQuestion(qptr))
9011 {
9012 LogInfo("mDNSCoreReceiveResponse: Setting aware for %##s (%s) on %#a", qptr->qname.c,
9013 DNSTypeName(qptr->qtype), &qptr->qDNSServer->addr);
9014 qptr->qDNSServer->DNSSECAware = mDNStrue;
9015 qptr->qDNSServer->req_DO = mDNStrue;
9016 }
9017 if (qptr->ValidatingResponse)
9018 DNSSECQuestion = mDNStrue;
9019 }
9020 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
9021 if (SameNameRecordAnswersQuestion(&rr->resrec, qptr))
9022 {
9023 debugf("uDNS marking %p %##s (%s) %p %s", q.InterfaceID, q.qname.c, DNSTypeName(q.qtype),
9024 rr->resrec.InterfaceID, CRDisplayString(m, rr));
9025 // Don't want to disturb rroriginalttl here, because code below might need it for the exponential backoff doubling algorithm
9026 rr->TimeRcvd = m->timenow - TicksTTL(rr) - 1;
9027 rr->UnansweredQueries = MaxUnansweredQueries;
9028 rr->CRDNSSECQuestion = 0;
9029 if (unicastQuestion && DNSSECQuestion(unicastQuestion))
9030 {
9031 LogInfo("mDNSCoreReceiveResponse: CRDNSSECQuestion set for record %s, question %##s (%s)", CRDisplayString(m, rr),
9032 unicastQuestion->qname.c, DNSTypeName(unicastQuestion->qtype));
9033 rr->CRDNSSECQuestion = 1;
9034 }
9035 }
9036 }
9037 else
9038 {
9039 if (qptr)
9040 {
9041 // If we recv any error from the DNSServer for a DNSSEC Query and if we know that the server
9042 // is not DNSSEC aware, stop doing DNSSEC for that DNSServer. Note that by setting the
9043 // req_DO to false here, the next retransmission for this question will turn off validation
9044 // and hence retransmit without the EDNS0/DOK option.
9045 if (DNSSECOptionalQuestion(qptr) && qptr->qDNSServer && !qptr->qDNSServer->DNSSECAware)
9046 {
9047 LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to DNSSEC Query %##s (%s), clear DO flag",
9048 qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype));
9049 qptr->qDNSServer->req_DO = mDNSfalse;
9050 }
9051 // For Unicast DNS Queries, penalize the DNSServer
9052 else
9053 {
9054 LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to query %##s (%s)",
9055 qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype));
9056 PenalizeDNSServer(m, qptr, response->h.flags);
9057 }
9058 }
9059 returnEarly = mDNStrue;
9060 }
9061 }
9062 }
9063 if (returnEarly)
9064 {
9065 LogInfo("Ignoring %2d Answer%s %2d Authorit%s %2d Additional%s",
9066 response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
9067 response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
9068 response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s");
9069 // not goto exit because we won't have any CacheFlushRecords and we do not want to
9070 // generate negative cache entries (we want to query the next server)
9071 return;
9072 }
9073 if (unicastQuestion && DNSSECQuestion(unicastQuestion))
9074 {
9075 BumpDNSSECStats(m, kStatsActionSet, kStatsTypeMsgSize, (end - response->data));
9076 }
9077 }
9078
9079 // Parse the NSEC3 records from the Authority section before we process
9080 // the Answer section so that we can cache them along with the proper
9081 // cache records we create.
9082 if (mDNSOpaque16IsZero(response->h.id))
9083 mDNSParseNSEC3Records(m, response, end, InterfaceID, &McastNSEC3Records);
9084
9085 for (i = 0; i < totalrecords && ptr && ptr < end; i++)
9086 {
9087 // All responses sent via LL multicast are acceptable for caching
9088 // All responses received over our outbound TCP connections are acceptable for caching
9089 // We accept all records in a unicast response to a multicast query once we find one that
9090 // answers an active question.
9091 mDNSBool AcceptableResponse = ResponseMCast || !dstaddr || LLQType || recordAcceptedInResponse;
9092 // (Note that just because we are willing to cache something, that doesn't necessarily make it a trustworthy answer
9093 // to any specific question -- any code reading records from the cache needs to make that determination for itself.)
9094
9095 const mDNSu8 RecordType =
9096 (i < firstauthority ) ? (mDNSu8)kDNSRecordTypePacketAns :
9097 (i < firstadditional) ? (mDNSu8)kDNSRecordTypePacketAuth : (mDNSu8)kDNSRecordTypePacketAdd;
9098 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &m->rec);
9099 if (!ptr) goto exit; // Break out of the loop and clean up our CacheFlushRecords list before exiting
9100
9101 if (m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative)
9102 {
9103 mDNSCoreResetRecord(m);
9104 continue;
9105 }
9106
9107 // We have already parsed the NSEC3 records and cached them approrpriately for
9108 // multicast responses.
9109 if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype == kDNSType_NSEC3)
9110 {
9111 mDNSCoreResetRecord(m);
9112 continue;
9113 }
9114 // Don't want to cache OPT or TSIG pseudo-RRs
9115 if (m->rec.r.resrec.rrtype == kDNSType_TSIG)
9116 {
9117 mDNSCoreResetRecord(m);
9118 continue;
9119 }
9120 if (m->rec.r.resrec.rrtype == kDNSType_OPT)
9121 {
9122 const rdataOPT *opt;
9123 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength];
9124 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently
9125 // delete all our own AuthRecords (which are identified by having zero MAC tags on them).
9126 for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++)
9127 if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0])
9128 {
9129 ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords);
9130 ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords);
9131 }
9132 mDNSCoreResetRecord(m);
9133 continue;
9134 }
9135 // if a CNAME record points to itself, then don't add it to the cache
9136 if ((m->rec.r.resrec.rrtype == kDNSType_CNAME) && SameDomainName(m->rec.r.resrec.name, &m->rec.r.resrec.rdata->u.name))
9137 {
9138 LogInfo("mDNSCoreReceiveResponse: CNAME loop domain name %##s", m->rec.r.resrec.name->c);
9139 mDNSCoreResetRecord(m);
9140 continue;
9141 }
9142
9143 // When we receive uDNS LLQ responses, we assume a long cache lifetime --
9144 // In the case of active LLQs, we'll get remove events when the records actually do go away
9145 // In the case of polling LLQs, we assume the record remains valid until the next poll
9146 if (!mDNSOpaque16IsZero(response->h.id))
9147 m->rec.r.resrec.rroriginalttl = GetEffectiveTTL(LLQType, m->rec.r.resrec.rroriginalttl);
9148
9149 // If response was not sent via LL multicast,
9150 // then see if it answers a recent query of ours, which would also make it acceptable for caching.
9151 if (!ResponseMCast)
9152 {
9153 if (LLQType)
9154 {
9155 // For Long Lived queries that are both sent over UDP and Private TCP, LLQType is set.
9156 // Even though it is AcceptableResponse, we need a matching DNSServer pointer for the
9157 // queries to get ADD/RMV events. To lookup the question, we can't use
9158 // ExpectingUnicastResponseForRecord as the port numbers don't match. uDNS_recvLLQRespose
9159 // has already matched the question using the 64 bit Id in the packet and we use that here.
9160
9161 if (llqMatch != mDNSNULL) m->rec.r.resrec.rDNSServer = uDNSServer = llqMatch->qDNSServer;
9162
9163 // If this is a DNSSEC question that is also LongLived, don't accept records from the
9164 // Additional/Authority section blindly. We need to go through IsAcceptableResponse below
9165 // so that NSEC/NSEC3 record are cached in the nseclist if we accept them. This can happen
9166 // for both negative responses and wildcard expanded positive responses as both of come
9167 // back with NSEC/NSEC3s.
9168 if (unicastQuestion && DNSSECQuestion(unicastQuestion))
9169 AcceptableResponse = mDNSfalse;
9170 }
9171 else if (!AcceptableResponse || !dstaddr)
9172 {
9173 // For responses that come over TCP (Responses that can't fit within UDP) or TLS (Private queries
9174 // that are not long lived e.g., AAAA lookup in a Private domain), it is indicated by !dstaddr.
9175 // Even though it is AcceptableResponse, we still need a DNSServer pointer for the resource records that
9176 // we create.
9177
9178 DNSQuestion *q = ExpectingUnicastResponseForRecord(m, srcaddr, ResponseSrcLocal, dstport, response->h.id, &m->rec.r, !dstaddr);
9179
9180 // Initialize the DNS server on the resource record which will now filter what questions we answer with
9181 // this record.
9182 //
9183 // We could potentially lookup the DNS server based on the source address, but that may not work always
9184 // and that's why ExpectingUnicastResponseForRecord does not try to verify whether the response came
9185 // from the DNS server that queried. We follow the same logic here. If we can find a matching quetion based
9186 // on the "id" and "source port", then this response answers the question and assume the response
9187 // came from the same DNS server that we sent the query to.
9188
9189 if (q != mDNSNULL)
9190 {
9191 AcceptableResponse = mDNStrue;
9192 if (!InterfaceID)
9193 {
9194 debugf("mDNSCoreReceiveResponse: InterfaceID %p %##s (%s)", q->InterfaceID, q->qname.c, DNSTypeName(q->qtype));
9195 m->rec.r.resrec.rDNSServer = uDNSServer = q->qDNSServer;
9196 }
9197 else
9198 {
9199 // Accept all remaining records in this unicast response to an mDNS query.
9200 recordAcceptedInResponse = mDNStrue;
9201 LogInfo("mDNSCoreReceiveResponse: Accepting response for query: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
9202 }
9203 }
9204 else
9205 {
9206 // If we can't find a matching question, we need to see whether we have seen records earlier that matched
9207 // the question. The code below does that. So, make this record unacceptable for now
9208 if (!InterfaceID)
9209 {
9210 debugf("mDNSCoreReceiveResponse: Can't find question for record name %##s", m->rec.r.resrec.name->c);
9211 AcceptableResponse = mDNSfalse;
9212 }
9213 }
9214 }
9215 }
9216 else if (llintf && llintf->IgnoreIPv4LL && m->rec.r.resrec.rrtype == kDNSType_A)
9217 {
9218 // There are some routers (rare, thankfully) that generate bogus ARP responses for
9219 // any IPv4 address they don’t recognize, including RFC 3927 IPv4 link-local addresses.
9220 // To work with these broken routers, client devices need to blacklist these broken
9221 // routers and ignore their bogus ARP responses. Some devices implement a technique
9222 // such as the one described in US Patent 7436783, which lets clients detect and
9223 // ignore these broken routers: <https://www.google.com/patents/US7436783>
9224
9225 // OS X and iOS do not implement this defensive mechanism, instead taking a simpler
9226 // approach of just detecting these broken routers and completely disabling IPv4
9227 // link-local communication on interfaces where a broken router is detected.
9228 // OS X and iOS set the IFEF_ARPLL interface flag on interfaces
9229 // that are deemed “safe” for IPv4 link-local communication;
9230 // the flag is cleared on interfaces where a broken router is detected.
9231
9232 // OS X and iOS will not even try to communicate with an IPv4
9233 // link-local destination on an interface without the IFEF_ARPLL flag set.
9234 // This can cause some badly written applications to freeze for a long time if they
9235 // attempt to connect to an IPv4 link-local destination address and then wait for
9236 // that connection attempt to time out before trying other candidate addresses.
9237
9238 // To mask this client bug, we suppress acceptance of IPv4 link-local address
9239 // records on interfaces where we know the OS will be unwilling even to attempt
9240 // communication with those IPv4 link-local destination addresses.
9241 // <rdar://problem/9400639> kSuppress IPv4LL answers on interfaces without IFEF_ARPLL
9242
9243 const CacheRecord *const rr = &m->rec.r;
9244 const RDataBody2 *const rdb = (RDataBody2 *)rr->smallrdatastorage.data;
9245 if (mDNSv4AddressIsLinkLocal(&rdb->ipv4))
9246 {
9247 LogInfo("mDNSResponder: Dropping LinkLocal packet %s", CRDisplayString(m, &m->rec.r));
9248 mDNSCoreResetRecord(m);
9249 continue;
9250 }
9251 }
9252
9253 // 1. Check that this packet resource record does not conflict with any of ours
9254 if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype != kDNSType_NSEC)
9255 {
9256 if (m->CurrentRecord)
9257 LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
9258 m->CurrentRecord = m->ResourceRecords;
9259 while (m->CurrentRecord)
9260 {
9261 AuthRecord *rr = m->CurrentRecord;
9262 m->CurrentRecord = rr->next;
9263 // We accept all multicast responses, and unicast responses resulting from queries we issued
9264 // For other unicast responses, this code accepts them only for responses with an
9265 // (apparently) local source address that pertain to a record of our own that's in probing state
9266 if (!AcceptableResponse && !(ResponseSrcLocal && rr->resrec.RecordType == kDNSRecordTypeUnique)) continue;
9267
9268 if (PacketRRMatchesSignature(&m->rec.r, rr)) // If interface, name, type (if shared record) and class match...
9269 {
9270 // ... check to see if type and rdata are identical
9271 if (IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec))
9272 {
9273 // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us
9274 if (m->rec.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState)
9275 {
9276 // If we were planning to send on this -- and only this -- interface, then we don't need to any more
9277 if (rr->ImmedAnswer == InterfaceID) { rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse; }
9278 }
9279 else
9280 {
9281 if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; }
9282 else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
9283 }
9284 }
9285 // else, the packet RR has different type or different rdata -- check to see if this is a conflict
9286 else if (m->rec.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &m->rec.r))
9287 {
9288 LogInfo("mDNSCoreReceiveResponse: Pkt Record: %08lX %s", m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r));
9289 LogInfo("mDNSCoreReceiveResponse: Our Record: %08lX %s", rr->resrec.rdatahash, ARDisplayString(m, rr));
9290
9291 // If this record is marked DependentOn another record for conflict detection purposes,
9292 // then *that* record has to be bumped back to probing state to resolve the conflict
9293 if (rr->DependentOn)
9294 {
9295 while (rr->DependentOn) rr = rr->DependentOn;
9296 LogInfo("mDNSCoreReceiveResponse: Dep Record: %08lX %s", rr->resrec.rdatahash, ARDisplayString(m, rr));
9297 }
9298
9299 // If we've just whacked this record's ProbeCount, don't need to do it again
9300 if (rr->ProbeCount > DefaultProbeCountForTypeUnique)
9301 LogInfo("mDNSCoreReceiveResponse: Already reset to Probing: %s", ARDisplayString(m, rr));
9302 else if (rr->ProbeCount == DefaultProbeCountForTypeUnique)
9303 LogInfo("mDNSCoreReceiveResponse: Ignoring response received before we even began probing: %s", ARDisplayString(m, rr));
9304 else
9305 {
9306 LogMsg("mDNSCoreReceiveResponse: Received from %#a:%d %s", srcaddr, mDNSVal16(srcport), CRDisplayString(m, &m->rec.r));
9307 // If we'd previously verified this record, put it back to probing state and try again
9308 if (rr->resrec.RecordType == kDNSRecordTypeVerified)
9309 {
9310 LogMsg("mDNSCoreReceiveResponse: Resetting to Probing: %s", ARDisplayString(m, rr));
9311 rr->resrec.RecordType = kDNSRecordTypeUnique;
9312 // We set ProbeCount to one more than the usual value so we know we've already touched this record.
9313 // This is because our single probe for "example-name.local" could yield a response with (say) two A records and
9314 // three AAAA records in it, and we don't want to call RecordProbeFailure() five times and count that as five conflicts.
9315 // This special value is recognised and reset to DefaultProbeCountForTypeUnique in SendQueries().
9316 rr->ProbeCount = DefaultProbeCountForTypeUnique + 1;
9317 rr->AnnounceCount = InitialAnnounceCount;
9318 InitializeLastAPTime(m, rr);
9319 RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate
9320 }
9321 // If we're probing for this record, we just failed
9322 else if (rr->resrec.RecordType == kDNSRecordTypeUnique)
9323 {
9324 // At this point in the code, we're probing for uniqueness.
9325 // We've sent at least one probe (rr->ProbeCount < DefaultProbeCountForTypeUnique)
9326 // but we haven't completed probing yet (rr->resrec.RecordType == kDNSRecordTypeUnique).
9327 // Before we call deregister, check if this is a packet we registered with the sleep proxy.
9328 if (!mDNSCoreRegisteredProxyRecord(m, rr))
9329 {
9330 // This may be a conflict due to stale packets on the network. Delay probing by a second.
9331 // If there are conflicts after 3 such attempts, then it is a true conflict.
9332 if (m->DelayConflictProcessing)
9333 {
9334 m->DelayConflictProcessing--;
9335 LogMsg("Possible spurious conflict for %s. Attempt %d at suppressing probes for one second",
9336 ARDisplayString(m, rr), (MAX_CONFLICT_PROCESSING_DELAYS - m->DelayConflictProcessing));
9337 rr->ProbeCount = DefaultProbeCountForTypeUnique + 1;
9338 rr->AnnounceCount = InitialAnnounceCount;
9339 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond);
9340 InitializeLastAPTime(m, rr);
9341 RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate
9342 }
9343 else
9344 {
9345 LogMsg("mDNSCoreReceiveResponse: ProbeCount %d; will deregister %s", rr->ProbeCount, ARDisplayString(m, rr));
9346 m->mDNSStats.NameConflicts++;
9347#if APPLE_OSX_mDNSResponder
9348 // See if this record was also registered with any D2D plugins.
9349 D2D_stop_advertising_record(rr);
9350#endif
9351 mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
9352 }
9353
9354 }
9355 }
9356 // We assumed this record must be unique, but we were wrong. (e.g. There are two mDNSResponders on the
9357 // same machine giving different answers for the reverse mapping record, or there are two machines on the
9358 // network using the same IP address.) This is simply a misconfiguration, and there's nothing we can do
9359 // to fix it -- e.g. it's not our job to be trying to change the machine's IP address. We just discard our
9360 // record to avoid continued conflicts (as we do for a conflict on our Unique records) and get on with life.
9361 else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique)
9362 {
9363 LogMsg("mDNSCoreReceiveResponse: Unexpected conflict discarding %s", ARDisplayString(m, rr));
9364 m->mDNSStats.KnownUniqueNameConflicts++;
9365#if APPLE_OSX_mDNSResponder
9366 D2D_stop_advertising_record(rr);
9367#endif
9368 mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
9369 }
9370 else
9371 LogMsg("mDNSCoreReceiveResponse: Unexpected record type %X %s", rr->resrec.RecordType, ARDisplayString(m, rr));
9372 }
9373 }
9374 // Else, matching signature, different type or rdata, but not a considered a conflict.
9375 // If the packet record has the cache-flush bit set, then we check to see if we
9376 // have any record(s) of the same type that we should re-assert to rescue them
9377 // (see note about "multi-homing and bridged networks" at the end of this function).
9378 else if (m->rec.r.resrec.rrtype == rr->resrec.rrtype)
9379 if ((m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (mDNSu32)(m->timenow - rr->LastMCTime) > (mDNSu32)mDNSPlatformOneSecond/2)
9380 { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
9381 }
9382 }
9383 }
9384
9385 nseclist = mDNSfalse;
9386 if (!AcceptableResponse)
9387 {
9388 AcceptableResponse = IsResponseAcceptable(m, CacheFlushRecords, unicastQuestion, &nseclist);
9389 if (AcceptableResponse) m->rec.r.resrec.rDNSServer = uDNSServer;
9390 }
9391
9392 // 2. See if we want to add this packet resource record to our cache
9393 // We only try to cache answers if we have a cache to put them in
9394 // Also, we ignore any apparent attempts at cache poisoning unicast to us that do not answer any outstanding active query
9395 if (!AcceptableResponse) LogInfo("mDNSCoreReceiveResponse ignoring %s", CRDisplayString(m, &m->rec.r));
9396 if (m->rrcache_size && AcceptableResponse)
9397 {
9398 const mDNSu32 slot = HashSlotFromNameHash(m->rec.r.resrec.namehash);
9399 CacheGroup *cg = CacheGroupForRecord(m, &m->rec.r.resrec);
9400 CacheRecord *rr = mDNSNULL;
9401
9402 if (McastNSEC3Records)
9403 InitializeAnonInfoForCR(m, &McastNSEC3Records, &m->rec.r);
9404
9405 // 2a. Check if this packet resource record is already in our cache.
9406 //
9407 // If this record should go in the nseclist, don't look in the cache for updating it.
9408 // They are supposed to be cached under the "nsec" field of the cache record for
9409 // validation. Just create the cache record.
9410 if (!nseclist)
9411 {
9412 rr = mDNSCoreReceiveCacheCheck(m, response, LLQType, slot, cg, unicastQuestion, &cfp, &NSECCachePtr, InterfaceID);
9413 }
9414
9415 // If packet resource record not in our cache, add it now
9416 // (unless it is just a deletion of a record we never had, in which case we don't care)
9417 if (!rr && m->rec.r.resrec.rroriginalttl > 0)
9418 {
9419 const mDNSBool AddToCFList = (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (LLQType != uDNS_LLQ_Events);
9420 mDNSs32 delay;
9421
9422 if (AddToCFList)
9423 delay = NonZeroTime(m->timenow + mDNSPlatformOneSecond);
9424 else
9425 delay = CheckForSoonToExpireRecords(m, m->rec.r.resrec.name, m->rec.r.resrec.namehash, mDNSNULL);
9426
9427 // If unique, assume we may have to delay delivery of this 'add' event.
9428 // Below, where we walk the CacheFlushRecords list, we either call CacheRecordDeferredAdd()
9429 // to immediately to generate answer callbacks, or we call ScheduleNextCacheCheckTime()
9430 // to schedule an mDNS_Execute task at the appropriate time.
9431 rr = CreateNewCacheEntry(m, slot, cg, delay, !nseclist, srcaddr);
9432 if (rr)
9433 {
9434 rr->responseFlags = response->h.flags;
9435 // If we are not creating signatures, then we need to inform DNSSEC so that
9436 // it does not wait forever. Don't do this if we got NSEC records
9437 // as it indicates that this name does not exist.
9438 if (rr->resrec.rrtype == kDNSType_RRSIG && !nseclist)
9439 {
9440 rrsigsCreated = mDNStrue;
9441 }
9442 // Remember whether we created a cache record in response to a DNSSEC question.
9443 // This helps DNSSEC code not to reissue the question to fetch the DNSSEC records.
9444 rr->CRDNSSECQuestion = 0;
9445 if (unicastQuestion && DNSSECQuestion(unicastQuestion))
9446 {
9447 LogInfo("mDNSCoreReceiveResponse: CRDNSSECQuestion set for new record %s, question %##s (%s)", CRDisplayString(m, rr),
9448 unicastQuestion->qname.c, DNSTypeName(unicastQuestion->qtype));
9449 rr->CRDNSSECQuestion = 1;
9450 }
9451 // NSEC/NSEC3 records and its signatures are cached with the negative cache entry
9452 // which we should be creating below. It is also needed in the wildcard
9453 // expanded answer case and in that case it is cached along with the answer.
9454 if (nseclist)
9455 {
9456 rr->TimeRcvd = m->timenow;
9457 *nsecp = rr;
9458 nsecp = &rr->next;
9459 }
9460 else if (AddToCFList)
9461 {
9462 *cfp = rr;
9463 cfp = &rr->NextInCFList;
9464 *cfp = (CacheRecord*)1;
9465 }
9466 else if (rr->DelayDelivery)
9467 {
9468 ScheduleNextCacheCheckTime(m, slot, rr->DelayDelivery);
9469 }
9470 }
9471 }
9472 else
9473 {
9474 if (rr && rr->resrec.AnonInfo && m->rec.r.resrec.AnonInfo)
9475 {
9476 CopyAnonInfoForCR(m, rr, &m->rec.r);
9477 }
9478 }
9479 }
9480 mDNSCoreResetRecord(m);
9481 }
9482
9483exit:
9484 mDNSCoreResetRecord(m);
9485
9486 // If we've just received one or more records with their cache flush bits set,
9487 // then scan that cache slot to see if there are any old stale records we need to flush
9488 while (CacheFlushRecords != (CacheRecord*)1)
9489 {
9490 CacheRecord *r1 = CacheFlushRecords, *r2;
9491 const mDNSu32 slot = HashSlotFromNameHash(r1->resrec.namehash);
9492 const CacheGroup *cg = CacheGroupForRecord(m, &r1->resrec);
9493 CacheFlushRecords = CacheFlushRecords->NextInCFList;
9494 r1->NextInCFList = mDNSNULL;
9495
9496 // Look for records in the cache with the same signature as this new one with the cache flush
9497 // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL
9498 // (as required by DNS semantics) or (b) if they're old, mark them for deletion in one second.
9499 // We make these TTL adjustments *only* for records that still have *more* than one second
9500 // remaining to live. Otherwise, a record that we tagged for deletion half a second ago
9501 // (and now has half a second remaining) could inadvertently get its life extended, by either
9502 // (a) if we got an explicit goodbye packet half a second ago, the record would be considered
9503 // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet,
9504 // or (b) otherwise, the record would not be fully resurrected, but would be reset to expire
9505 // in one second, thereby inadvertently delaying its actual expiration, instead of hastening it.
9506 // If this were to happen repeatedly, the record's expiration could be deferred indefinitely.
9507 // To avoid this, we need to ensure that the cache flushing operation will only act to
9508 // *decrease* a record's remaining lifetime, never *increase* it.
9509 for (r2 = cg ? cg->members : mDNSNULL; r2; r2=r2->next)
9510 {
9511 mDNSu16 id1;
9512 mDNSu16 id2;
9513 if (!r1->resrec.InterfaceID)
9514 {
9515 id1 = (r1->resrec.rDNSServer ? r1->resrec.rDNSServer->resGroupID : 0);
9516 id2 = (r2->resrec.rDNSServer ? r2->resrec.rDNSServer->resGroupID : 0);
9517 }
9518 else
9519 {
9520 id1 = id2 = 0;
9521 }
9522 // When we receive new RRSIGs e.g., for DNSKEY record, we should not flush the old
9523 // RRSIGS e.g., for TXT record. To do so, we need to look at the typeCovered field of
9524 // the new RRSIG that we received. Process only if the typeCovered matches.
9525 if ((r1->resrec.rrtype == r2->resrec.rrtype) && (r1->resrec.rrtype == kDNSType_RRSIG))
9526 {
9527 rdataRRSig *rrsig1 = (rdataRRSig *)(((RDataBody2 *)(r1->resrec.rdata->u.data))->data);
9528 rdataRRSig *rrsig2 = (rdataRRSig *)(((RDataBody2 *)(r2->resrec.rdata->u.data))->data);
9529 if (swap16(rrsig1->typeCovered) != swap16(rrsig2->typeCovered))
9530 {
9531 debugf("mDNSCoreReceiveResponse: Received RRSIG typeCovered %s, found %s, not processing",
9532 DNSTypeName(swap16(rrsig1->typeCovered)), DNSTypeName(swap16(rrsig2->typeCovered)));
9533 continue;
9534 }
9535 }
9536
9537 // For Unicast (null InterfaceID) the resolver IDs should also match
9538 if ((r1->resrec.InterfaceID == r2->resrec.InterfaceID) &&
9539 (r1->resrec.InterfaceID || (id1 == id2)) &&
9540 r1->resrec.rrtype == r2->resrec.rrtype &&
9541 r1->resrec.rrclass == r2->resrec.rrclass)
9542 {
9543 // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics)
9544 // else, if record is old, mark it to be flushed
9545 if (m->timenow - r2->TimeRcvd < mDNSPlatformOneSecond && RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond)
9546 {
9547 // If we find mismatched TTLs in an RRSet, correct them.
9548 // We only do this for records with a TTL of 2 or higher. It's possible to have a
9549 // goodbye announcement with the cache flush bit set (or a case-change on record rdata,
9550 // which we treat as a goodbye followed by an addition) and in that case it would be
9551 // inappropriate to synchronize all the other records to a TTL of 0 (or 1).
9552
9553 // We suppress the message for the specific case of correcting from 240 to 60 for type TXT,
9554 // because certain early Bonjour devices are known to have this specific mismatch, and
9555 // there's no point filling syslog with messages about something we already know about.
9556 // We also don't log this for uDNS responses, since a caching name server is obliged
9557 // to give us an aged TTL to correct for how long it has held the record,
9558 // so our received TTLs are expected to vary in that case
9559
9560 // We also suppress log message in the case of SRV records that are received
9561 // with a TTL of 4500 that are already cached with a TTL of 120 seconds, since
9562 // this behavior was observed for a number of discoveryd based AppleTV's in iOS 8
9563 // GM builds.
9564 if (r2->resrec.rroriginalttl != r1->resrec.rroriginalttl && r1->resrec.rroriginalttl > 1)
9565 {
9566 if (!(r2->resrec.rroriginalttl == 240 && r1->resrec.rroriginalttl == 60 && r2->resrec.rrtype == kDNSType_TXT) &&
9567 !(r2->resrec.rroriginalttl == 120 && r1->resrec.rroriginalttl == 4500 && r2->resrec.rrtype == kDNSType_SRV) &&
9568 mDNSOpaque16IsZero(response->h.id))
9569 LogInfo("Correcting TTL from %4d to %4d for %s",
9570 r2->resrec.rroriginalttl, r1->resrec.rroriginalttl, CRDisplayString(m, r2));
9571 r2->resrec.rroriginalttl = r1->resrec.rroriginalttl;
9572 }
9573 r2->TimeRcvd = m->timenow;
9574 }
9575 else // else, if record is old, mark it to be flushed
9576 {
9577 verbosedebugf("Cache flush new %p age %d expire in %d %s", r1, m->timenow - r1->TimeRcvd, RRExpireTime(r1) - m->timenow, CRDisplayString(m, r1));
9578 verbosedebugf("Cache flush old %p age %d expire in %d %s", r2, m->timenow - r2->TimeRcvd, RRExpireTime(r2) - m->timenow, CRDisplayString(m, r2));
9579 // We set stale records to expire in one second.
9580 // This gives the owner a chance to rescue it if necessary.
9581 // This is important in the case of multi-homing and bridged networks:
9582 // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be
9583 // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit
9584 // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet
9585 // will promptly delete their cached copies of the (still valid) Ethernet IP address record.
9586 // By delaying the deletion by one second, we give X a change to notice that this bridging has
9587 // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches.
9588
9589 // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary
9590 // final expiration queries for this record.
9591
9592 // If a record is deleted twice, first with an explicit DE record, then a second time by virtue of the cache
9593 // flush bit on the new record replacing it, then we allow the record to be deleted immediately, without the usual
9594 // one-second grace period. This improves responsiveness for mDNS_Update(), as used for things like iChat status updates.
9595 // <rdar://problem/5636422> Updating TXT records is too slow
9596 // We check for "rroriginalttl == 1" because we want to include records tagged by the "packet TTL is zero" check above,
9597 // which sets rroriginalttl to 1, but not records tagged by the rdata case-change check, which sets rroriginalttl to 0.
9598 if (r2->TimeRcvd == m->timenow && r2->resrec.rroriginalttl == 1 && r2->UnansweredQueries == MaxUnansweredQueries)
9599 {
9600 LogInfo("Cache flush for DE record %s", CRDisplayString(m, r2));
9601 r2->resrec.rroriginalttl = 0;
9602 }
9603 else if (RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond)
9604 {
9605 // We only set a record to expire in one second if it currently has *more* than a second to live
9606 // If it's already due to expire in a second or less, we just leave it alone
9607 r2->resrec.rroriginalttl = 1;
9608 r2->UnansweredQueries = MaxUnansweredQueries;
9609 r2->TimeRcvd = m->timenow - 1;
9610 // We use (m->timenow - 1) instead of m->timenow, because we use that to identify records
9611 // that we marked for deletion via an explicit DE record
9612 }
9613 }
9614 SetNextCacheCheckTimeForRecord(m, r2);
9615 }
9616 }
9617
9618 if (r1->DelayDelivery) // If we were planning to delay delivery of this record, see if we still need to
9619 {
9620 // If we had a unicast question for this response with at least one positive answer and we
9621 // have NSECRecords, it is most likely a wildcard expanded answer. Cache the NSEC and its
9622 // signatures along with the cache record which will be used for validation later. If
9623 // we rescued a few records earlier in this function, then NSECCachePtr would be set. In that
9624 // use that instead.
9625 if (response->h.numAnswers && unicastQuestion && NSECRecords)
9626 {
9627 if (!NSECCachePtr)
9628 {
9629 LogInfo("mDNSCoreReceiveResponse: Updating NSECCachePtr to %s", CRDisplayString(m, r1));
9630 NSECCachePtr = r1;
9631 }
9632 // Note: We need to do this before we call CacheRecordDeferredAdd as this
9633 // might start the verification process which needs these NSEC records
9634 if (!AddNSECSForCacheRecord(m, NSECRecords, NSECCachePtr, rcode))
9635 {
9636 LogInfo("mDNSCoreReceiveResponse: AddNSECSForCacheRecord failed to add NSEC for %s", CRDisplayString(m, NSECCachePtr));
9637 FreeNSECRecords(m, NSECRecords);
9638 }
9639 NSECRecords = mDNSNULL;
9640 NSECCachePtr = mDNSNULL;
9641 }
9642 r1->DelayDelivery = CheckForSoonToExpireRecords(m, r1->resrec.name, r1->resrec.namehash, mDNSNULL);
9643 // If no longer delaying, deliver answer now, else schedule delivery for the appropriate time
9644 if (!r1->DelayDelivery) CacheRecordDeferredAdd(m, r1);
9645 else ScheduleNextCacheCheckTime(m, slot, r1->DelayDelivery);
9646 }
9647 }
9648
9649 // If we have not consumed the NSEC records yet e.g., just refreshing the cache,
9650 // update them now for future validations.
9651 if (NSECRecords && NSECCachePtr)
9652 {
9653 LogInfo("mDNSCoreReceieveResponse: Updating NSEC records in %s", CRDisplayString(m, NSECCachePtr));
9654 if (!AddNSECSForCacheRecord(m, NSECRecords, NSECCachePtr, rcode))
9655 {
9656 LogInfo("mDNSCoreReceiveResponse: AddNSECSForCacheRecord failed to add NSEC for %s", CRDisplayString(m, NSECCachePtr));
9657 FreeNSECRecords(m, NSECRecords);
9658 }
9659 NSECRecords = mDNSNULL;
9660 NSECCachePtr = mDNSNULL;
9661 }
9662
9663 // If there is at least one answer and we did not create RRSIGs and there was a
9664 // ValidatingResponse question waiting for this response, give a hint that no RRSIGs
9665 // were created. We don't need to give a hint:
9666 //
9667 // - if we have no answers, the mDNSCoreReceiveNoUnicastAnswers below should
9668 // generate a negative response
9669 //
9670 // - if we have NSECRecords, it means we might have a potential proof for
9671 // non-existence of name that we are looking for
9672 //
9673 if (response->h.numAnswers && !rrsigsCreated && DNSSECQuestion && !NSECRecords)
9674 mDNSCoreReceiveNoDNSSECAnswers(m, response, end, dstaddr, dstport, InterfaceID);
9675
9676 // See if we need to generate negative cache entries for unanswered unicast questions
9677 mDNSCoreReceiveNoUnicastAnswers(m, response, end, dstaddr, dstport, InterfaceID, LLQType, rcode, NSECRecords);
9678
9679 if (McastNSEC3Records)
9680 {
9681 debugf("mDNSCoreReceiveResponse: McastNSEC3Records not used");
9682 FreeNSECRecords(m, McastNSEC3Records);
9683 }
9684}
9685
9686// ScheduleWakeup causes all proxy records with WakeUp.HMAC matching mDNSEthAddr 'e' to be deregistered, causing
9687// multiple wakeup magic packets to be sent if appropriate, and all records to be ultimately freed after a few seconds.
9688// ScheduleWakeup is called on mDNS record conflicts, ARP conflicts, NDP conflicts, or reception of trigger traffic
9689// that warrants waking the sleeping host.
9690// ScheduleWakeup must be called with the lock held (ScheduleWakeupForList uses mDNS_Deregister_internal)
9691
9692mDNSlocal void ScheduleWakeupForList(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e, AuthRecord *const thelist)
9693{
9694 // We need to use the m->CurrentRecord mechanism here when dealing with DuplicateRecords list as
9695 // mDNS_Deregister_internal deregisters duplicate records immediately as they are not used
9696 // to send wakeups or goodbyes. See the comment in that function for more details. To keep it
9697 // simple, we use the same mechanism for both lists.
9698 if (!e->l[0])
9699 {
9700 LogMsg("ScheduleWakeupForList ERROR: Target HMAC is zero");
9701 return;
9702 }
9703 m->CurrentRecord = thelist;
9704 while (m->CurrentRecord)
9705 {
9706 AuthRecord *const rr = m->CurrentRecord;
9707 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && mDNSSameEthAddress(&rr->WakeUp.HMAC, e))
9708 {
9709 LogInfo("ScheduleWakeupForList: Scheduling wakeup packets for %s", ARDisplayString(m, rr));
9710 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
9711 }
9712 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
9713 m->CurrentRecord = rr->next;
9714 }
9715}
9716
9717mDNSlocal void ScheduleWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e)
9718{
9719 if (!e->l[0]) { LogMsg("ScheduleWakeup ERROR: Target HMAC is zero"); return; }
9720 ScheduleWakeupForList(m, InterfaceID, e, m->DuplicateRecords);
9721 ScheduleWakeupForList(m, InterfaceID, e, m->ResourceRecords);
9722}
9723
9724mDNSlocal void SPSRecordCallback(mDNS *const m, AuthRecord *const ar, mStatus result)
9725{
9726 if (result && result != mStatus_MemFree)
9727 LogInfo("SPS Callback %d %s", result, ARDisplayString(m, ar));
9728
9729 if (result == mStatus_NameConflict)
9730 {
9731 mDNS_Lock(m);
9732 LogMsg("%-7s Conflicting mDNS -- waking %.6a %s", InterfaceNameForID(m, ar->resrec.InterfaceID), &ar->WakeUp.HMAC, ARDisplayString(m, ar));
9733 if (ar->WakeUp.HMAC.l[0])
9734 {
9735 SendWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.IMAC, &ar->WakeUp.password, mDNSfalse); // Send one wakeup magic packet
9736 ScheduleWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.HMAC); // Schedule all other records with the same owner to be woken
9737 }
9738 mDNS_Unlock(m);
9739 }
9740
9741 if (result == mStatus_NameConflict || result == mStatus_MemFree)
9742 {
9743 m->ProxyRecords--;
9744 mDNSPlatformMemFree(ar);
9745 mDNS_UpdateAllowSleep(m);
9746 }
9747}
9748
9749mDNSlocal mDNSu8 *GetValueForMACAddr(mDNSu8 *ptr, mDNSu8 *limit, mDNSEthAddr *eth)
9750{
9751 int i;
9752 mDNSs8 hval = 0;
9753 int colons = 0;
9754 mDNSu8 val = 0;
9755
9756 for (i = 0; ptr < limit && *ptr != ' ' && i < 17; i++, ptr++)
9757 {
9758 hval = HexVal(*ptr);
9759 if (hval != -1)
9760 {
9761 val <<= 4;
9762 val |= hval;
9763 }
9764 else if (*ptr == ':')
9765 {
9766 if (colons >=5)
9767 {
9768 LogMsg("GetValueForMACAddr: Address malformed colons %d val %d", colons, val);
9769 return mDNSNULL;
9770 }
9771 eth->b[colons] = val;
9772 colons++;
9773 val = 0;
9774 }
9775 }
9776 if (colons != 5)
9777 {
9778 LogMsg("GetValueForMACAddr: Address malformed colons %d", colons);
9779 return mDNSNULL;
9780 }
9781 eth->b[colons] = val;
9782 return ptr;
9783}
9784
9785mDNSlocal mDNSu8 *GetValueForIPv6Addr(mDNSu8 *ptr, mDNSu8 *limit, mDNSv6Addr *v6)
9786{
9787 int hval;
9788 int value;
9789 int numBytes;
9790 int digitsProcessed;
9791 int zeroFillStart;
9792 int numColons;
9793 mDNSu8 v6addr[16];
9794
9795 // RFC 3513: Section 2.2 specifies IPv6 presentation format. The following parsing
9796 // handles both (1) and (2) and does not handle embedded IPv4 addresses.
9797 //
9798 // First forms a address in "v6addr", then expands to fill the zeroes in and returns
9799 // the result in "v6"
9800
9801 numColons = numBytes = value = digitsProcessed = zeroFillStart = 0;
9802 while (ptr < limit && *ptr != ' ')
9803 {
9804 hval = HexVal(*ptr);
9805 if (hval != -1)
9806 {
9807 value <<= 4;
9808 value |= hval;
9809 digitsProcessed = 1;
9810 }
9811 else if (*ptr == ':')
9812 {
9813 if (!digitsProcessed)
9814 {
9815 // If we have already seen a "::", we should not see one more. Handle the special
9816 // case of "::"
9817 if (numColons)
9818 {
9819 // if we never filled any bytes and the next character is space (we have reached the end)
9820 // we are done
9821 if (!numBytes && (ptr + 1) < limit && *(ptr + 1) == ' ')
9822 {
9823 mDNSPlatformMemZero(v6->b, 16);
9824 return ptr + 1;
9825 }
9826 LogMsg("GetValueForIPv6Addr: zeroFillStart non-zero %d", zeroFillStart);
9827 return mDNSNULL;
9828 }
9829
9830 // We processed "::". We need to fill zeroes later. For now, mark the
9831 // point where we will start filling zeroes from.
9832 zeroFillStart = numBytes;
9833 numColons++;
9834 }
9835 else if ((ptr + 1) < limit && *(ptr + 1) == ' ')
9836 {
9837 // We have a trailing ":" i.e., no more characters after ":"
9838 LogMsg("GetValueForIPv6Addr: Trailing colon");
9839 return mDNSNULL;
9840 }
9841 else
9842 {
9843 // For a fully expanded IPv6 address, we fill the 14th and 15th byte outside of this while
9844 // loop below as there is no ":" at the end. Hence, the last two bytes that can possibly
9845 // filled here is 12 and 13.
9846 if (numBytes > 13) { LogMsg("GetValueForIPv6Addr:1: numBytes is %d", numBytes); return mDNSNULL; }
9847
9848 v6addr[numBytes++] = (mDNSu8) ((value >> 8) & 0xFF);
9849 v6addr[numBytes++] = (mDNSu8) (value & 0xFF);
9850 digitsProcessed = value = 0;
9851
9852 // Make sure that we did not fill the 13th and 14th byte above
9853 if (numBytes > 14) { LogMsg("GetValueForIPv6Addr:2: numBytes is %d", numBytes); return mDNSNULL; }
9854 }
9855 }
9856 ptr++;
9857 }
9858
9859 // We should be processing the last set of bytes following the last ":" here
9860 if (!digitsProcessed)
9861 {
9862 LogMsg("GetValueForIPv6Addr: no trailing bytes after colon, numBytes is %d", numBytes);
9863 return mDNSNULL;
9864 }
9865
9866 if (numBytes > 14) { LogMsg("GetValueForIPv6Addr:3: numBytes is %d", numBytes); return mDNSNULL; }
9867 v6addr[numBytes++] = (mDNSu8) ((value >> 8) & 0xFF);
9868 v6addr[numBytes++] = (mDNSu8) (value & 0xFF);
9869
9870 if (zeroFillStart)
9871 {
9872 int i, j, n;
9873 for (i = 0; i < zeroFillStart; i++)
9874 v6->b[i] = v6addr[i];
9875 for (j = i, n = 0; n < 16 - numBytes; j++, n++)
9876 v6->b[j] = 0;
9877 for (; j < 16; i++, j++)
9878 v6->b[j] = v6addr[i];
9879 }
9880 else if (numBytes == 16)
9881 mDNSPlatformMemCopy(v6->b, v6addr, 16);
9882 else
9883 {
9884 LogMsg("GetValueForIPv6addr: Not enough bytes for IPv6 address, numBytes is %d", numBytes);
9885 return mDNSNULL;
9886 }
9887 return ptr;
9888}
9889
9890mDNSlocal mDNSu8 *GetValueForIPv4Addr(mDNSu8 *ptr, mDNSu8 *limit, mDNSv4Addr *v4)
9891{
9892 mDNSu32 val;
9893 int dots = 0;
9894 val = 0;
9895
9896 for ( ; ptr < limit && *ptr != ' '; ptr++)
9897 {
9898 if (*ptr >= '0' && *ptr <= '9')
9899 val = val * 10 + *ptr - '0';
9900 else if (*ptr == '.')
9901 {
9902 if (val > 255 || dots >= 3)
9903 {
9904 LogMsg("GetValueForIPv4Addr: something wrong ptr(%p) %c, limit %p, dots %d", ptr, *ptr, limit, dots);
9905 return mDNSNULL;
9906 }
9907 v4->b[dots++] = val;
9908 val = 0;
9909 }
9910 else
9911 {
9912 // We have a zero at the end and if we reached that, then we are done.
9913 if (*ptr == 0 && ptr == limit - 1 && dots == 3)
9914 {
9915 v4->b[dots] = val;
9916 return ptr + 1;
9917 }
9918 else { LogMsg("GetValueForIPv4Addr: something wrong ptr(%p) %c, limit %p, dots %d", ptr, *ptr, limit, dots); return mDNSNULL; }
9919 }
9920 }
9921 if (dots != 3) { LogMsg("GetValueForIPv4Addr: Address malformed dots %d", dots); return mDNSNULL; }
9922 v4->b[dots] = val;
9923 return ptr;
9924}
9925
9926mDNSlocal mDNSu8 *GetValueForKeepalive(mDNSu8 *ptr, mDNSu8 *limit, mDNSu32 *value)
9927{
9928 mDNSu32 val;
9929
9930 val = 0;
9931 for ( ; ptr < limit && *ptr != ' '; ptr++)
9932 {
9933 if (*ptr < '0' || *ptr > '9')
9934 {
9935 // We have a zero at the end and if we reached that, then we are done.
9936 if (*ptr == 0 && ptr == limit - 1)
9937 {
9938 *value = val;
9939 return ptr + 1;
9940 }
9941 else { LogMsg("GetValueForKeepalive: *ptr %d, ptr %p, limit %p, ptr +1 %d", *ptr, ptr, limit, *(ptr + 1)); return mDNSNULL; }
9942 }
9943 val = val * 10 + *ptr - '0';
9944 }
9945 *value = val;
9946 return ptr;
9947}
9948
9949mDNSexport mDNSBool mDNSValidKeepAliveRecord(AuthRecord *rr)
9950{
9951 mDNSAddr laddr, raddr;
9952 mDNSEthAddr eth;
9953 mDNSIPPort lport, rport;
9954 mDNSu32 timeout, seq, ack;
9955 mDNSu16 win;
9956
9957 if (!mDNS_KeepaliveRecord(&rr->resrec))
9958 {
9959 return mDNSfalse;
9960 }
9961
9962 timeout = seq = ack = 0;
9963 win = 0;
9964 laddr = raddr = zeroAddr;
9965 lport = rport = zeroIPPort;
9966 eth = zeroEthAddr;
9967
9968 mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, &raddr, &eth, &seq, &ack, &lport, &rport, &win);
9969
9970 if (mDNSAddressIsZero(&laddr) || mDNSIPPortIsZero(lport) ||
9971 mDNSAddressIsZero(&raddr) || mDNSIPPortIsZero(rport) ||
9972 mDNSEthAddressIsZero(eth))
9973 {
9974 return mDNSfalse;
9975 }
9976
9977 return mDNStrue;
9978}
9979
9980
9981mDNSlocal void mDNS_ExtractKeepaliveInfo(AuthRecord *ar, mDNSu32 *timeout, mDNSAddr *laddr, mDNSAddr *raddr, mDNSEthAddr *eth, mDNSu32 *seq,
9982 mDNSu32 *ack, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu16 *win)
9983{
9984 if (ar->resrec.rrtype != kDNSType_NULL)
9985 return;
9986
9987 if (mDNS_KeepaliveRecord(&ar->resrec))
9988 {
9989 int len = ar->resrec.rdlength;
9990 mDNSu8 *ptr = &ar->resrec.rdata->u.txt.c[1];
9991 mDNSu8 *limit = ptr + len - 1; // Exclude the first byte that is the length
9992 mDNSu32 value = 0;
9993
9994 while (ptr < limit)
9995 {
9996 mDNSu8 param = *ptr;
9997 ptr += 2; // Skip the letter and the "="
9998 if (param == 'h')
9999 {
10000 laddr->type = mDNSAddrType_IPv4;
10001 ptr = GetValueForIPv4Addr(ptr, limit, &laddr->ip.v4);
10002 }
10003 else if (param == 'd')
10004 {
10005 raddr->type = mDNSAddrType_IPv4;
10006 ptr = GetValueForIPv4Addr(ptr, limit, &raddr->ip.v4);
10007 }
10008 else if (param == 'H')
10009 {
10010 laddr->type = mDNSAddrType_IPv6;
10011 ptr = GetValueForIPv6Addr(ptr, limit, &laddr->ip.v6);
10012 }
10013 else if (param == 'D')
10014 {
10015 raddr->type = mDNSAddrType_IPv6;
10016 ptr = GetValueForIPv6Addr(ptr, limit, &raddr->ip.v6);
10017 }
10018 else if (param == 'm')
10019 {
10020 ptr = GetValueForMACAddr(ptr, limit, eth);
10021 }
10022 else
10023 {
10024 ptr = GetValueForKeepalive(ptr, limit, &value);
10025 }
10026 if (!ptr) { LogMsg("mDNS_ExtractKeepaliveInfo: Cannot parse\n"); return; }
10027
10028 // Extract everything in network order so that it is easy for sending a keepalive and also
10029 // for matching incoming TCP packets
10030 switch (param)
10031 {
10032 case 't':
10033 *timeout = value;
10034 //if (*timeout < 120) *timeout = 120;
10035 break;
10036 case 'h':
10037 case 'H':
10038 case 'd':
10039 case 'D':
10040 case 'm':
10041 case 'i':
10042 case 'c':
10043 break;
10044 case 'l':
10045 lport->NotAnInteger = swap16((mDNSu16)value);
10046 break;
10047 case 'r':
10048 rport->NotAnInteger = swap16((mDNSu16)value);
10049 break;
10050 case 's':
10051 *seq = swap32(value);
10052 break;
10053 case 'a':
10054 *ack = swap32(value);
10055 break;
10056 case 'w':
10057 *win = swap16((mDNSu16)value);
10058 break;
10059 default:
10060 LogMsg("mDNS_ExtractKeepaliveInfo: unknown value %c\n", param);
10061 ptr = limit;
10062 break;
10063 }
10064 ptr++; // skip the space
10065 }
10066 }
10067}
10068
10069// Matches the proxied auth records to the incoming TCP packet and returns the match and its sequence and ack in "rseq" and "rack" so that
10070// the clients need not retrieve this information from the auth record again.
10071mDNSlocal AuthRecord* mDNS_MatchKeepaliveInfo(mDNS *const m, const mDNSAddr* pladdr, const mDNSAddr* praddr, const mDNSIPPort plport,
10072 const mDNSIPPort prport, mDNSu32 *rseq, mDNSu32 *rack)
10073{
10074 AuthRecord *ar;
10075 mDNSAddr laddr, raddr;
10076 mDNSEthAddr eth;
10077 mDNSIPPort lport, rport;
10078 mDNSu32 timeout, seq, ack;
10079 mDNSu16 win;
10080
10081 for (ar = m->ResourceRecords; ar; ar=ar->next)
10082 {
10083 timeout = seq = ack = 0;
10084 win = 0;
10085 laddr = raddr = zeroAddr;
10086 lport = rport = zeroIPPort;
10087
10088 if (!ar->WakeUp.HMAC.l[0]) continue;
10089
10090 mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, &eth, &seq, &ack, &lport, &rport, &win);
10091
10092 // Did we parse correctly ?
10093 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win)
10094 {
10095 debugf("mDNS_MatchKeepaliveInfo: not a valid record %s for keepalive", ARDisplayString(m, ar));
10096 continue;
10097 }
10098
10099 debugf("mDNS_MatchKeepaliveInfo: laddr %#a pladdr %#a, raddr %#a praddr %#a, lport %d plport %d, rport %d prport %d",
10100 &laddr, pladdr, &raddr, praddr, mDNSVal16(lport), mDNSVal16(plport), mDNSVal16(rport), mDNSVal16(prport));
10101
10102 // Does it match the incoming TCP packet ?
10103 if (mDNSSameAddress(&laddr, pladdr) && mDNSSameAddress(&raddr, praddr) && mDNSSameIPPort(lport, plport) && mDNSSameIPPort(rport, prport))
10104 {
10105 // returning in network order
10106 *rseq = seq;
10107 *rack = ack;
10108 return ar;
10109 }
10110 }
10111 return mDNSNULL;
10112}
10113
10114mDNSlocal void mDNS_SendKeepalives(mDNS *const m)
10115{
10116 AuthRecord *ar;
10117
10118 for (ar = m->ResourceRecords; ar; ar=ar->next)
10119 {
10120 mDNSu32 timeout, seq, ack;
10121 mDNSu16 win;
10122 mDNSAddr laddr, raddr;
10123 mDNSEthAddr eth;
10124 mDNSIPPort lport, rport;
10125
10126 timeout = seq = ack = 0;
10127 win = 0;
10128
10129 laddr = raddr = zeroAddr;
10130 lport = rport = zeroIPPort;
10131
10132 if (!ar->WakeUp.HMAC.l[0]) continue;
10133
10134 mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, &eth, &seq, &ack, &lport, &rport, &win);
10135
10136 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win)
10137 {
10138 debugf("mDNS_SendKeepalives: not a valid record %s for keepalive", ARDisplayString(m, ar));
10139 continue;
10140 }
10141 LogMsg("mDNS_SendKeepalives: laddr %#a raddr %#a lport %d rport %d", &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport));
10142
10143 // When we receive a proxy update, we set KATimeExpire to zero so that we always send a keepalive
10144 // immediately (to detect any potential problems). After that we always set it to a non-zero value.
10145 if (!ar->KATimeExpire || (m->timenow - ar->KATimeExpire >= 0))
10146 {
10147 mDNSPlatformSendKeepalive(&laddr, &raddr, &lport, &rport, seq, ack, win);
10148 ar->KATimeExpire = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond);
10149 }
10150 if (m->NextScheduledKA - ar->KATimeExpire > 0)
10151 m->NextScheduledKA = ar->KATimeExpire;
10152 }
10153}
10154
10155mDNSlocal void mDNS_SendKeepaliveACK(mDNS *const m, AuthRecord *ar)
10156{
10157 mDNSu32 timeout, seq, ack, seqInc;
10158 mDNSu16 win;
10159 mDNSAddr laddr, raddr;
10160 mDNSEthAddr eth;
10161 mDNSIPPort lport, rport;
10162 mDNSu8 *ptr;
10163
10164 if (ar == mDNSNULL)
10165 {
10166 LogInfo("mDNS_SendKeepalivesACK: AuthRecord is NULL");
10167 return;
10168 }
10169
10170 timeout = seq = ack = 0;
10171 win = 0;
10172
10173 laddr = raddr = zeroAddr;
10174 lport = rport = zeroIPPort;
10175
10176 mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, &eth, &seq, &ack, &lport, &rport, &win);
10177
10178 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win)
10179 {
10180 LogInfo("mDNS_SendKeepaliveACK: not a valid record %s for keepalive", ARDisplayString(m, ar));
10181 return;
10182 }
10183
10184 // To send a keepalive ACK, we need to add one to the sequence number from the keepalive
10185 // record, which is the TCP connection's "next" sequence number minus one. Otherwise, the
10186 // keepalive ACK also ends up being a keepalive probe. Also, seq is in network byte order, so
10187 // it's converted to host byte order before incrementing it by one.
10188 ptr = (mDNSu8 *)&seq;
10189 seqInc = (mDNSu32)((ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3]) + 1;
10190 ptr[0] = (mDNSu8)((seqInc >> 24) & 0xFF);
10191 ptr[1] = (mDNSu8)((seqInc >> 16) & 0xFF);
10192 ptr[2] = (mDNSu8)((seqInc >> 8) & 0xFF);
10193 ptr[3] = (mDNSu8)((seqInc ) & 0xFF);
10194 LogMsg("mDNS_SendKeepaliveACK: laddr %#a raddr %#a lport %d rport %d", &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport));
10195 mDNSPlatformSendKeepalive(&laddr, &raddr, &lport, &rport, seq, ack, win);
10196}
10197
10198mDNSlocal void mDNSCoreReceiveUpdate(mDNS *const m,
10199 const DNSMessage *const msg, const mDNSu8 *end,
10200 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
10201 const mDNSInterfaceID InterfaceID)
10202{
10203 int i;
10204 AuthRecord opt;
10205 mDNSu8 *p = m->omsg.data;
10206 OwnerOptData owner = zeroOwner; // Need to zero this, so we'll know if this Update packet was missing its Owner option
10207 mDNSu32 updatelease = 0;
10208 const mDNSu8 *ptr;
10209
10210 LogSPS("Received Update from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
10211 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes",
10212 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
10213 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,",
10214 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,",
10215 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,",
10216 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data);
10217
10218 if (!InterfaceID || !m->SPSSocket || !mDNSSameIPPort(dstport, m->SPSSocket->port)) return;
10219
10220 if (mDNS_PacketLoggingEnabled)
10221 DumpPacket(m, mStatus_NoError, mDNSfalse, "UDP", srcaddr, srcport, dstaddr, dstport, msg, end);
10222
10223 ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space + DNSOpt_OwnerData_ID_Space);
10224 if (ptr)
10225 {
10226 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
10227 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT)
10228 {
10229 const rdataOPT *o;
10230 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength];
10231 for (o = &m->rec.r.resrec.rdata->u.opt[0]; o < e; o++)
10232 {
10233 if (o->opt == kDNSOpt_Lease) updatelease = o->u.updatelease;
10234 else if (o->opt == kDNSOpt_Owner && o->u.owner.vers == 0) owner = o->u.owner;
10235 }
10236 }
10237 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
10238 }
10239
10240 InitializeDNSMessage(&m->omsg.h, msg->h.id, UpdateRespFlags);
10241
10242 if (!updatelease || !owner.HMAC.l[0])
10243 {
10244 static int msgs = 0;
10245 if (msgs < 100)
10246 {
10247 msgs++;
10248 LogMsg("Refusing sleep proxy registration from %#a:%d:%s%s", srcaddr, mDNSVal16(srcport),
10249 !updatelease ? " No lease" : "", !owner.HMAC.l[0] ? " No owner" : "");
10250 }
10251 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_FormErr;
10252 }
10253 else if (m->ProxyRecords + msg->h.mDNS_numUpdates > MAX_PROXY_RECORDS)
10254 {
10255 static int msgs = 0;
10256 if (msgs < 100)
10257 {
10258 msgs++;
10259 LogMsg("Refusing sleep proxy registration from %#a:%d: Too many records %d + %d = %d > %d", srcaddr, mDNSVal16(srcport),
10260 m->ProxyRecords, msg->h.mDNS_numUpdates, m->ProxyRecords + msg->h.mDNS_numUpdates, MAX_PROXY_RECORDS);
10261 }
10262 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused;
10263 }
10264 else
10265 {
10266 LogSPS("Received Update for H-MAC %.6a I-MAC %.6a Password %.6a seq %d", &owner.HMAC, &owner.IMAC, &owner.password, owner.seq);
10267
10268 if (updatelease > 24 * 60 * 60)
10269 updatelease = 24 * 60 * 60;
10270
10271 if (updatelease > 0x40000000UL / mDNSPlatformOneSecond)
10272 updatelease = 0x40000000UL / mDNSPlatformOneSecond;
10273
10274 ptr = LocateAuthorities(msg, end);
10275
10276 // Clear any stale TCP keepalive records that may exist
10277 ClearKeepaliveProxyRecords(m, &owner, m->DuplicateRecords, InterfaceID);
10278 ClearKeepaliveProxyRecords(m, &owner, m->ResourceRecords, InterfaceID);
10279
10280 for (i = 0; i < msg->h.mDNS_numUpdates && ptr && ptr < end; i++)
10281 {
10282 ptr = GetLargeResourceRecord(m, msg, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
10283 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative)
10284 {
10285 mDNSu16 RDLengthMem = GetRDLengthMem(&m->rec.r.resrec);
10286 AuthRecord *ar = mDNSPlatformMemAllocate(sizeof(AuthRecord) - sizeof(RDataBody) + RDLengthMem);
10287 if (!ar)
10288 {
10289 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused;
10290 break;
10291 }
10292 else
10293 {
10294 mDNSu8 RecordType = m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask ? kDNSRecordTypeUnique : kDNSRecordTypeShared;
10295 m->rec.r.resrec.rrclass &= ~kDNSClass_UniqueRRSet;
10296 // All stale keepalive records have been flushed prior to this loop.
10297 if (!mDNS_KeepaliveRecord(&m->rec.r.resrec))
10298 {
10299 ClearIdenticalProxyRecords(m, &owner, m->DuplicateRecords); // Make sure we don't have any old stale duplicates of this record
10300 ClearIdenticalProxyRecords(m, &owner, m->ResourceRecords);
10301 }
10302 mDNS_SetupResourceRecord(ar, mDNSNULL, InterfaceID, m->rec.r.resrec.rrtype, m->rec.r.resrec.rroriginalttl, RecordType, AuthRecordAny, SPSRecordCallback, ar);
10303 AssignDomainName(&ar->namestorage, m->rec.r.resrec.name);
10304 ar->resrec.rdlength = GetRDLength(&m->rec.r.resrec, mDNSfalse);
10305 ar->resrec.rdata->MaxRDLength = RDLengthMem;
10306 mDNSPlatformMemCopy(ar->resrec.rdata->u.data, m->rec.r.resrec.rdata->u.data, RDLengthMem);
10307 ar->ForceMCast = mDNStrue;
10308 ar->WakeUp = owner;
10309 if (m->rec.r.resrec.rrtype == kDNSType_PTR)
10310 {
10311 mDNSs32 t = ReverseMapDomainType(m->rec.r.resrec.name);
10312 if (t == mDNSAddrType_IPv4) GetIPv4FromName(&ar->AddressProxy, m->rec.r.resrec.name);
10313 else if (t == mDNSAddrType_IPv6) GetIPv6FromName(&ar->AddressProxy, m->rec.r.resrec.name);
10314 debugf("mDNSCoreReceiveUpdate: PTR %d %d %#a %s", t, ar->AddressProxy.type, &ar->AddressProxy, ARDisplayString(m, ar));
10315 if (ar->AddressProxy.type) SetSPSProxyListChanged(InterfaceID);
10316 }
10317 ar->TimeRcvd = m->timenow;
10318 ar->TimeExpire = m->timenow + updatelease * mDNSPlatformOneSecond;
10319 if (m->NextScheduledSPS - ar->TimeExpire > 0)
10320 m->NextScheduledSPS = ar->TimeExpire;
10321 ar->KATimeExpire = 0;
10322 mDNS_Register_internal(m, ar);
10323
10324 m->ProxyRecords++;
10325 mDNS_UpdateAllowSleep(m);
10326 LogSPS("SPS Registered %4d %X %s", m->ProxyRecords, RecordType, ARDisplayString(m,ar));
10327 }
10328 }
10329 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
10330 }
10331
10332 if (m->omsg.h.flags.b[1] & kDNSFlag1_RC_Mask)
10333 {
10334 LogMsg("Refusing sleep proxy registration from %#a:%d: Out of memory", srcaddr, mDNSVal16(srcport));
10335 ClearProxyRecords(m, &owner, m->DuplicateRecords);
10336 ClearProxyRecords(m, &owner, m->ResourceRecords);
10337 }
10338 else
10339 {
10340 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
10341 opt.resrec.rrclass = NormalMaxDNSMessageData;
10342 opt.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
10343 opt.resrec.rdestimate = sizeof(rdataOPT);
10344 opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease;
10345 opt.resrec.rdata->u.opt[0].u.updatelease = updatelease;
10346 p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData);
10347 }
10348 }
10349
10350 if (p) mDNSSendDNSMessage(m, &m->omsg, p, InterfaceID, m->SPSSocket, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse);
10351 mDNS_SendKeepalives(m);
10352}
10353
10354mDNSlocal mDNSu32 mDNSGenerateOwnerOptForInterface(mDNS *const m, const mDNSInterfaceID InterfaceID, DNSMessage *msg)
10355{
10356 mDNSu8 *ptr = msg->data;
10357 mDNSu8 *end = mDNSNULL;
10358 mDNSu32 length = 0;
10359 AuthRecord opt;
10360 NetworkInterfaceInfo *intf;
10361
10362 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
10363 opt.resrec.rrclass = NormalMaxDNSMessageData;
10364 opt.resrec.rdlength = sizeof(rdataOPT);
10365 opt.resrec.rdestimate = sizeof(rdataOPT);
10366
10367 intf = FirstInterfaceForID(m, InterfaceID);
10368 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]);
10369
10370 LogSPS("Generated OPT record : %s", ARDisplayString(m, &opt));
10371 end = PutResourceRecord(msg, ptr, &msg->h.numAdditionals, &opt.resrec);
10372 if (end != mDNSNULL)
10373 {
10374 // Put all the integer values in IETF byte-order (MSB first, LSB second)
10375 SwapDNSHeaderBytes(msg);
10376 length = (end - msg->data);
10377 }
10378 else
10379 LogSPS("mDNSGenerateOwnerOptForInterface: Failed to generate owner OPT record");
10380
10381 return length;
10382}
10383
10384// Note that this routine is called both for Sleep Proxy Registrations, and for Standard Dynamic
10385// DNS registrations, but (currently) only has to handle the Sleep Proxy Registration reply case,
10386// and should ignore Standard Dynamic DNS registration replies, because those are handled elsewhere.
10387// Really, both should be unified and handled in one place.
10388mDNSlocal void mDNSCoreReceiveUpdateR(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *end, const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID)
10389{
10390 if (InterfaceID)
10391 {
10392 mDNSu32 pktlease = 0, spsupdates = 0;
10393 const mDNSBool gotlease = GetPktLease(m, msg, end, &pktlease);
10394 const mDNSu32 updatelease = gotlease ? pktlease : 60 * 60; // If SPS fails to indicate lease time, assume one hour
10395 if (gotlease) LogSPS("DNS Update response contains lease option granting %4d seconds, updateid %d, InterfaceID %p", updatelease, mDNSVal16(msg->h.id), InterfaceID);
10396
10397 if (m->CurrentRecord)
10398 LogMsg("mDNSCoreReceiveUpdateR ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
10399 m->CurrentRecord = m->ResourceRecords;
10400 while (m->CurrentRecord)
10401 {
10402 AuthRecord *const rr = m->CurrentRecord;
10403 if (rr->resrec.InterfaceID == InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name))))
10404 if (mDNSSameOpaque16(rr->updateid, msg->h.id))
10405 {
10406 // We successfully completed this record's registration on this "InterfaceID". Clear that bit.
10407 // Clear the updateid when we are done sending on all interfaces.
10408 mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, InterfaceID, mDNStrue);
10409 if (scopeid < (sizeof(rr->updateIntID) * mDNSNBBY))
10410 bit_clr_opaque64(rr->updateIntID, scopeid);
10411 if (mDNSOpaque64IsZero(&rr->updateIntID))
10412 rr->updateid = zeroID;
10413 rr->expire = NonZeroTime(m->timenow + updatelease * mDNSPlatformOneSecond);
10414 spsupdates++;
10415 LogSPS("Sleep Proxy %s record %2d %5d 0x%x 0x%x (%d) %s", rr->WakeUp.HMAC.l[0] ? "transferred" : "registered", spsupdates, updatelease, rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr));
10416 if (rr->WakeUp.HMAC.l[0])
10417 {
10418 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host
10419 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it
10420 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
10421 }
10422 }
10423 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
10424 // new records could have been added to the end of the list as a result of that call.
10425 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
10426 m->CurrentRecord = rr->next;
10427 }
10428 if (spsupdates) // Only do this dynamic store stuff if this was, in fact, a Sleep Proxy Update response
10429 {
10430 char *ifname;
10431 mDNSAddr spsaddr;
10432 DNSMessage optMsg;
10433 int length;
10434 // Update the dynamic store with the IP Address and MAC address of the sleep proxy
10435 ifname = InterfaceNameForID(m, InterfaceID);
10436 mDNSPlatformMemCopy(&spsaddr, srcaddr, sizeof (mDNSAddr));
10437 mDNSPlatformStoreSPSMACAddr(&spsaddr, ifname);
10438
10439 // Store the Owner OPT record for this interface.
10440 // Configd may use the OPT record if it detects a conflict with the BSP when the system wakes up
10441 InitializeDNSMessage(&optMsg.h, zeroID, ResponseFlags);
10442 length = mDNSGenerateOwnerOptForInterface(m, InterfaceID, &optMsg);
10443 if (length != 0)
10444 {
10445 length += sizeof(DNSMessageHeader);
10446 mDNSPlatformStoreOwnerOptRecord(ifname, &optMsg, length);
10447 }
10448 }
10449 }
10450 // If we were waiting to go to sleep, then this SPS registration or wide-area record deletion
10451 // may have been the thing we were waiting for, so schedule another check to see if we can sleep now.
10452 if (m->SleepLimit) m->NextScheduledSPRetry = m->timenow;
10453}
10454
10455mDNSexport void MakeNegativeCacheRecord(mDNS *const m, CacheRecord *const cr,
10456 const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds, mDNSInterfaceID InterfaceID, DNSServer *dnsserver)
10457{
10458 if (cr == &m->rec.r && m->rec.r.resrec.RecordType)
10459 LogFatalError("MakeNegativeCacheRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r));
10460
10461 // Create empty resource record
10462 cr->resrec.RecordType = kDNSRecordTypePacketNegative;
10463 cr->resrec.InterfaceID = InterfaceID;
10464 cr->resrec.rDNSServer = dnsserver;
10465 cr->resrec.name = name; // Will be updated to point to cg->name when we call CreateNewCacheEntry
10466 cr->resrec.rrtype = rrtype;
10467 cr->resrec.rrclass = rrclass;
10468 cr->resrec.rroriginalttl = ttl_seconds;
10469 cr->resrec.rdlength = 0;
10470 cr->resrec.rdestimate = 0;
10471 cr->resrec.namehash = namehash;
10472 cr->resrec.rdatahash = 0;
10473 cr->resrec.rdata = (RData*)&cr->smallrdatastorage;
10474 cr->resrec.rdata->MaxRDLength = 0;
10475
10476 cr->NextInKAList = mDNSNULL;
10477 cr->TimeRcvd = m->timenow;
10478 cr->DelayDelivery = 0;
10479 cr->NextRequiredQuery = m->timenow;
10480 cr->LastUsed = m->timenow;
10481 cr->CRActiveQuestion = mDNSNULL;
10482 cr->UnansweredQueries = 0;
10483 cr->LastUnansweredTime = 0;
10484 cr->NextInCFList = mDNSNULL;
10485 cr->nsec = mDNSNULL;
10486 cr->soa = mDNSNULL;
10487 cr->CRDNSSECQuestion = 0;
10488 // Initialize to the basic one and the caller can set it to more
10489 // specific based on the response if any
10490 cr->responseFlags = ResponseFlags;
10491}
10492
10493mDNSexport void mDNSCoreReceive(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
10494 const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, const mDNSIPPort dstport,
10495 const mDNSInterfaceID InterfaceID)
10496{
10497 mDNSInterfaceID ifid = InterfaceID;
10498 const mDNSu8 *const pkt = (mDNSu8 *)msg;
10499 const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery;
10500 const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
10501 const mDNSu8 UpdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_Update;
10502 const mDNSu8 UpdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update;
10503 mDNSu8 QR_OP;
10504 mDNSu8 *ptr = mDNSNULL;
10505 mDNSBool TLS = (dstaddr == (mDNSAddr *)1); // For debug logs: dstaddr = 0 means TCP; dstaddr = 1 means TLS
10506 if (TLS) dstaddr = mDNSNULL;
10507
10508#ifndef UNICAST_DISABLED
10509 if (mDNSSameAddress(srcaddr, &m->Router))
10510 {
10511#ifdef _LEGACY_NAT_TRAVERSAL_
10512 if (mDNSSameIPPort(srcport, SSDPPort) || (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port)))
10513 {
10514 mDNS_Lock(m);
10515 LNT_ConfigureRouterInfo(m, InterfaceID, (mDNSu8 *)msg, (mDNSu16)(end - pkt));
10516 mDNS_Unlock(m);
10517 return;
10518 }
10519#endif
10520 if (mDNSSameIPPort(srcport, NATPMPPort))
10521 {
10522 mDNS_Lock(m);
10523 uDNS_ReceiveNATPacket(m, InterfaceID, (mDNSu8 *)msg, (mDNSu16)(end - pkt));
10524 mDNS_Unlock(m);
10525 return;
10526 }
10527 }
10528#ifdef _LEGACY_NAT_TRAVERSAL_
10529 else if (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port)) { debugf("Ignoring SSDP response from %#a:%d", srcaddr, mDNSVal16(srcport)); return; }
10530#endif
10531
10532#endif
10533 if ((unsigned)(end - pkt) < sizeof(DNSMessageHeader))
10534 {
10535 LogMsg("DNS Message from %#a:%d to %#a:%d length %d too short", srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), (int)(end - pkt));
10536 return;
10537 }
10538 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
10539 // Read the integer parts which are in IETF byte-order (MSB first, LSB second)
10540 ptr = (mDNSu8 *)&msg->h.numQuestions;
10541 msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
10542 msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
10543 msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
10544 msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]);
10545
10546 if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; }
10547
10548 // We use zero addresses and all-ones addresses at various places in the code to indicate special values like "no address"
10549 // If we accept and try to process a packet with zero or all-ones source address, that could really mess things up
10550 if (srcaddr && !mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; }
10551
10552 mDNS_Lock(m);
10553 m->PktNum++;
10554 if (mDNSOpaque16IsZero(msg->h.id))
10555 {
10556 m->MPktNum++;
10557#if APPLE_OSX_mDNSResponder
10558 // Track the number of multicast packets received from a source outside our subnet.
10559 // Check the destination address to avoid accounting for spurious packets that
10560 // comes in with message id zero.
10561 if (!mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr) && dstaddr &&
10562 mDNSAddressIsAllDNSLinkGroup(dstaddr))
10563 {
10564 m->RemoteSubnet++;
10565 }
10566#endif // #if APPLE_OSX_mDNSResponder
10567 }
10568
10569#ifndef UNICAST_DISABLED
10570 if (!dstaddr || (!mDNSAddressIsAllDNSLinkGroup(dstaddr) && (QR_OP == StdR || QR_OP == UpdR)))
10571 if (!mDNSOpaque16IsZero(msg->h.id)) // uDNS_ReceiveMsg only needs to get real uDNS responses, not "QU" mDNS responses
10572 {
10573 ifid = mDNSInterface_Any;
10574 if (mDNS_PacketLoggingEnabled)
10575 DumpPacket(m, mStatus_NoError, mDNSfalse, TLS ? "TLS" : !dstaddr ? "TCP" : "UDP", srcaddr, srcport, dstaddr, dstport, msg, end);
10576 uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport);
10577 // Note: mDNSCore also needs to get access to received unicast responses
10578 }
10579#endif
10580 if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid);
10581 else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid);
10582 else if (QR_OP == UpdQ) mDNSCoreReceiveUpdate (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID);
10583 else if (QR_OP == UpdR) mDNSCoreReceiveUpdateR (m, msg, end, srcaddr, InterfaceID);
10584 else
10585 {
10586 if (mDNS_LoggingEnabled)
10587 {
10588 static int msgCount = 0;
10589 if (msgCount < 1000) {
10590 int i = 0;
10591 msgCount++;
10592 LogInfo("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d length %d on %p (ignored)",
10593 msg->h.flags.b[0], msg->h.flags.b[1], srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), (int)(end - pkt), InterfaceID);
10594 while (i < (int)(end - pkt))
10595 {
10596 char buffer[128];
10597 char *p = buffer + mDNS_snprintf(buffer, sizeof(buffer), "%04X", i);
10598 do if (i < (int)(end - pkt)) p += mDNS_snprintf(p, sizeof(buffer), " %02X", pkt[i]);while (++i & 15);
10599 LogInfo("%s", buffer);
10600 }
10601 }
10602 }
10603 }
10604 // Packet reception often causes a change to the task list:
10605 // 1. Inbound queries can cause us to need to send responses
10606 // 2. Conflicing response packets received from other hosts can cause us to need to send defensive responses
10607 // 3. Other hosts announcing deletion of shared records can cause us to need to re-assert those records
10608 // 4. Response packets that answer questions may cause our client to issue new questions
10609 mDNS_Unlock(m);
10610}
10611
10612// ***************************************************************************
10613#if COMPILER_LIKES_PRAGMA_MARK
10614#pragma mark -
10615#pragma mark - Searcher Functions
10616#endif
10617
10618// Targets are considered the same if both queries are untargeted, or
10619// if both are targeted to the same address+port
10620// (If Target address is zero, TargetPort is undefined)
10621#define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \
10622 (mDNSSameAddress(& (A)->Target, & (B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort)))
10623
10624// SameQuestionKind is true if *both* questions are either multicast or unicast
10625// TargetQID is used for this determination.
10626#define SameQuestionKind(A,B) ((mDNSOpaque16IsZero(A) && mDNSOpaque16IsZero(B)) || \
10627 ((!mDNSOpaque16IsZero(A)) && (!mDNSOpaque16IsZero(B))))
10628
10629// Note: We explicitly disallow making a public query be a duplicate of a private one. This is to avoid the
10630// circular deadlock where a client does a query for something like "dns-sd -Q _dns-query-tls._tcp.company.com SRV"
10631// and we have a key for company.com, so we try to locate the private query server for company.com, which necessarily entails
10632// doing a standard DNS query for the _dns-query-tls._tcp SRV record for company.com. If we make the latter (public) query
10633// a duplicate of the former (private) query, then it will block forever waiting for an answer that will never come.
10634//
10635// We keep SuppressUnusable questions separate so that we can return a quick response to them and not get blocked behind
10636// the queries that are not marked SuppressUnusable. But if the query is not suppressed, they are treated the same as
10637// non-SuppressUnusable questions. This should be fine as the goal of SuppressUnusable is to return quickly only if it
10638// is suppressed. If it is not suppressed, we do try all the DNS servers for valid answers like any other question.
10639// The main reason for this design is that cache entries point to a *single* question and that question is responsible
10640// for keeping the cache fresh as long as it is active. Having multiple active question for a single cache entry
10641// breaks this design principle.
10642//
10643
10644// If IsLLQ(Q) is true, it means the question is both:
10645// (a) long-lived and
10646// (b) being performed by a unicast DNS long-lived query (either full LLQ, or polling)
10647// for multicast questions, we don't want to treat LongLived as anything special
10648#define IsLLQ(Q) ((Q)->LongLived && !mDNSOpaque16IsZero((Q)->TargetQID))
10649#define IsAWDLIncluded(Q) (((Q)->flags & kDNSServiceFlagsIncludeAWDL) != 0)
10650
10651mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question)
10652{
10653 DNSQuestion *q;
10654 // Note: A question can only be marked as a duplicate of one that occurs *earlier* in the list.
10655 // This prevents circular references, where two questions are each marked as a duplicate of the other.
10656 // Accordingly, we break out of the loop when we get to 'question', because there's no point searching
10657 // further in the list.
10658 for (q = m->Questions; q && q != question; q=q->next) // Scan our list for another question
10659 if (q->InterfaceID == question->InterfaceID && // with the same InterfaceID,
10660 SameQTarget(q, question) && // and same unicast/multicast target settings
10661 q->qtype == question->qtype && // type,
10662 q->qclass == question->qclass && // class,
10663 IsLLQ(q) == IsLLQ(question) && // and long-lived status matches
10664 (!q->AuthInfo || question->AuthInfo) && // to avoid deadlock, don't make public query dup of a private one
10665 (q->AnonInfo == question->AnonInfo) && // Anonymous query not a dup of normal query
10666 (q->SuppressQuery == question->SuppressQuery) && // Questions that are suppressed/not suppressed
10667 (q->ValidationRequired == question->ValidationRequired) && // Questions that require DNSSEC validation
10668 (q->ValidatingResponse == question->ValidatingResponse) && // Questions that are validating responses using DNSSEC
10669 (q->DisallowPID == question->DisallowPID) && // Disallowing a PID should not affect a PID that is allowed
10670 (q->BrowseThreshold == question->BrowseThreshold) && // browse thresholds must match
10671 q->qnamehash == question->qnamehash &&
10672 (IsAWDLIncluded(q) == IsAWDLIncluded(question)) && // Inclusion of AWDL interface must match
10673 SameQuestionKind(q->TargetQID, question->TargetQID) && // mDNS or uDNS must match
10674 SameDomainName(&q->qname, &question->qname)) // and name
10675 return(q);
10676 return(mDNSNULL);
10677}
10678
10679// This is called after a question is deleted, in case other identical questions were being suppressed as duplicates
10680mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, DNSQuestion *const question)
10681{
10682 DNSQuestion *q;
10683 DNSQuestion *first = mDNSNULL;
10684
10685 // This is referring to some other question as duplicate. No other question can refer to this
10686 // question as a duplicate.
10687 if (question->DuplicateOf)
10688 {
10689 LogInfo("UpdateQuestionDuplicates: question %p %##s (%s) duplicate of %p %##s (%s)",
10690 question, question->qname.c, DNSTypeName(question->qtype),
10691 question->DuplicateOf, question->DuplicateOf->qname.c, DNSTypeName(question->DuplicateOf->qtype));
10692 return;
10693 }
10694
10695 for (q = m->Questions; q; q=q->next) // Scan our list of questions
10696 if (q->DuplicateOf == question) // To see if any questions were referencing this as their duplicate
10697 {
10698 q->DuplicateOf = first;
10699 if (!first)
10700 {
10701 first = q;
10702 // If q used to be a duplicate, but now is not,
10703 // then inherit the state from the question that's going away
10704 q->LastQTime = question->LastQTime;
10705 q->ThisQInterval = question->ThisQInterval;
10706 q->ExpectUnicastResp = question->ExpectUnicastResp;
10707 q->LastAnswerPktNum = question->LastAnswerPktNum;
10708 q->RecentAnswerPkts = question->RecentAnswerPkts;
10709 q->RequestUnicast = question->RequestUnicast;
10710 q->LastQTxTime = question->LastQTxTime;
10711 q->CNAMEReferrals = question->CNAMEReferrals;
10712 q->nta = question->nta;
10713 q->servAddr = question->servAddr;
10714 q->servPort = question->servPort;
10715 q->qDNSServer = question->qDNSServer;
10716 q->validDNSServers = question->validDNSServers;
10717 q->unansweredQueries = question->unansweredQueries;
10718 q->noServerResponse = question->noServerResponse;
10719 q->triedAllServersOnce = question->triedAllServersOnce;
10720
10721 q->TargetQID = question->TargetQID;
10722 q->LocalSocket = question->LocalSocket;
10723 // No need to close old q->LocalSocket first -- duplicate questions can't have their own sockets
10724
10725 q->state = question->state;
10726 // q->tcp = question->tcp;
10727 q->ReqLease = question->ReqLease;
10728 q->expire = question->expire;
10729 q->ntries = question->ntries;
10730 q->id = question->id;
10731
10732 question->LocalSocket = mDNSNULL;
10733 question->nta = mDNSNULL; // If we've got a GetZoneData in progress, transfer it to the newly active question
10734 // question->tcp = mDNSNULL;
10735
10736 if (q->LocalSocket)
10737 debugf("UpdateQuestionDuplicates transferred LocalSocket pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
10738
10739 if (q->nta)
10740 {
10741 LogInfo("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
10742 q->nta->ZoneDataContext = q;
10743 }
10744
10745 // Need to work out how to safely transfer this state too -- appropriate context pointers need to be updated or the code will crash
10746 if (question->tcp) LogInfo("UpdateQuestionDuplicates did not transfer tcp pointer");
10747
10748 if (question->state == LLQ_Established)
10749 {
10750 LogInfo("UpdateQuestionDuplicates transferred LLQ state for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
10751 question->state = 0; // Must zero question->state, or mDNS_StopQuery_internal will clean up and cancel our LLQ from the server
10752 }
10753
10754 SetNextQueryTime(m,q);
10755 }
10756 }
10757}
10758
10759mDNSexport McastResolver *mDNS_AddMcastResolver(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, mDNSu32 timeout)
10760{
10761 McastResolver **p = &m->McastResolvers;
10762 McastResolver *tmp = mDNSNULL;
10763
10764 if (!d) d = (const domainname *)"";
10765
10766 LogInfo("mDNS_AddMcastResolver: Adding %##s, InterfaceID %p, timeout %u", d->c, interface, timeout);
10767
10768 mDNS_CheckLock(m);
10769
10770 while (*p) // Check if we already have this {interface, domain} tuple registered
10771 {
10772 if ((*p)->interface == interface && SameDomainName(&(*p)->domain, d))
10773 {
10774 if (!((*p)->flags & McastResolver_FlagDelete)) LogMsg("Note: Mcast Resolver domain %##s (%p) registered more than once", d->c, interface);
10775 (*p)->flags &= ~McastResolver_FlagDelete;
10776 tmp = *p;
10777 *p = tmp->next;
10778 tmp->next = mDNSNULL;
10779 }
10780 else
10781 p=&(*p)->next;
10782 }
10783
10784 if (tmp) *p = tmp; // move to end of list, to ensure ordering from platform layer
10785 else
10786 {
10787 // allocate, add to list
10788 *p = mDNSPlatformMemAllocate(sizeof(**p));
10789 if (!*p) LogMsg("mDNS_AddMcastResolver: ERROR!! - malloc");
10790 else
10791 {
10792 (*p)->interface = interface;
10793 (*p)->flags = McastResolver_FlagNew;
10794 (*p)->timeout = timeout;
10795 AssignDomainName(&(*p)->domain, d);
10796 (*p)->next = mDNSNULL;
10797 }
10798 }
10799 return(*p);
10800}
10801
10802mDNSinline mDNSs32 PenaltyTimeForServer(mDNS *m, DNSServer *server)
10803{
10804 mDNSs32 ptime = 0;
10805 if (server->penaltyTime != 0)
10806 {
10807 ptime = server->penaltyTime - m->timenow;
10808 if (ptime < 0)
10809 {
10810 // This should always be a positive value between 0 and DNSSERVER_PENALTY_TIME
10811 // If it does not get reset in ResetDNSServerPenalties for some reason, we do it
10812 // here
10813 LogMsg("PenaltyTimeForServer: PenaltyTime negative %d, (server penaltyTime %d, timenow %d) resetting the penalty",
10814 ptime, server->penaltyTime, m->timenow);
10815 server->penaltyTime = 0;
10816 ptime = 0;
10817 }
10818 }
10819 return ptime;
10820}
10821
10822//Checks to see whether the newname is a better match for the name, given the best one we have
10823//seen so far (given in bestcount).
10824//Returns -1 if the newname is not a better match
10825//Returns 0 if the newname is the same as the old match
10826//Returns 1 if the newname is a better match
10827mDNSlocal int BetterMatchForName(const domainname *name, int namecount, const domainname *newname, int newcount,
10828 int bestcount)
10829{
10830 // If the name contains fewer labels than the new server's domain or the new name
10831 // contains fewer labels than the current best, then it can't possibly be a better match
10832 if (namecount < newcount || newcount < bestcount) return -1;
10833
10834 // If there is no match, return -1 and the caller will skip this newname for
10835 // selection
10836 //
10837 // If we find a match and the number of labels is the same as bestcount, then
10838 // we return 0 so that the caller can do additional logic to pick one of
10839 // the best based on some other factors e.g., penaltyTime
10840 //
10841 // If we find a match and the number of labels is more than bestcount, then we
10842 // return 1 so that the caller can pick this over the old one.
10843 //
10844 // Note: newcount can either be equal or greater than bestcount beause of the
10845 // check above.
10846
10847 if (SameDomainName(SkipLeadingLabels(name, namecount - newcount), newname))
10848 return bestcount == newcount ? 0 : 1;
10849 else
10850 return -1;
10851}
10852
10853// Normally, we have McastResolvers for .local, in-addr.arpa and ip6.arpa. But there
10854// can be queries that can forced to multicast (ForceMCast) even though they don't end in these
10855// names. In that case, we give a default timeout of 5 seconds
10856#define DEFAULT_MCAST_TIMEOUT 5
10857mDNSlocal mDNSu32 GetTimeoutForMcastQuestion(mDNS *m, DNSQuestion *question)
10858{
10859 McastResolver *curmatch = mDNSNULL;
10860 int bestmatchlen = -1, namecount = CountLabels(&question->qname);
10861 McastResolver *curr;
10862 int bettermatch, currcount;
10863 for (curr = m->McastResolvers; curr; curr = curr->next)
10864 {
10865 currcount = CountLabels(&curr->domain);
10866 bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen);
10867 // Take the first best match. If there are multiple equally good matches (bettermatch = 0), we take
10868 // the timeout value from the first one
10869 if (bettermatch == 1)
10870 {
10871 curmatch = curr;
10872 bestmatchlen = currcount;
10873 }
10874 }
10875 LogInfo("GetTimeoutForMcastQuestion: question %##s curmatch %p, Timeout %d", question->qname.c, curmatch,
10876 curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT);
10877 return ( curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT);
10878}
10879
10880// Returns true if it is a Domain Enumeration Query
10881mDNSexport mDNSBool DomainEnumQuery(const domainname *qname)
10882{
10883 const mDNSu8 *mDNS_DEQLabels[] = { (const mDNSu8 *)"\001b", (const mDNSu8 *)"\002db", (const mDNSu8 *)"\002lb",
10884 (const mDNSu8 *)"\001r", (const mDNSu8 *)"\002dr", (const mDNSu8 *)mDNSNULL, };
10885 const domainname *d = qname;
10886 const mDNSu8 *label;
10887 int i = 0;
10888
10889 // We need at least 3 labels (DEQ prefix) + one more label to make a meaningful DE query
10890 if (CountLabels(qname) < 4) { debugf("DomainEnumQuery: question %##s, not enough labels", qname->c); return mDNSfalse; }
10891
10892 label = (const mDNSu8 *)d;
10893 while (mDNS_DEQLabels[i] != (const mDNSu8 *)mDNSNULL)
10894 {
10895 if (SameDomainLabel(mDNS_DEQLabels[i], label)) {debugf("DomainEnumQuery: DEQ %##s, label1 match", qname->c); break;}
10896 i++;
10897 }
10898 if (mDNS_DEQLabels[i] == (const mDNSu8 *)mDNSNULL)
10899 {
10900 debugf("DomainEnumQuery: Not a DEQ %##s, label1 mismatch", qname->c);
10901 return mDNSfalse;
10902 }
10903 debugf("DomainEnumQuery: DEQ %##s, label1 match", qname->c);
10904
10905 // CountLabels already verified the number of labels
10906 d = (const domainname *)(d->c + 1 + d->c[0]); // Second Label
10907 label = (const mDNSu8 *)d;
10908 if (!SameDomainLabel(label, (const mDNSu8 *)"\007_dns-sd"))
10909 {
10910 debugf("DomainEnumQuery: Not a DEQ %##s, label2 mismatch", qname->c);
10911 return(mDNSfalse);
10912 }
10913 debugf("DomainEnumQuery: DEQ %##s, label2 match", qname->c);
10914
10915 d = (const domainname *)(d->c + 1 + d->c[0]); // Third Label
10916 label = (const mDNSu8 *)d;
10917 if (!SameDomainLabel(label, (const mDNSu8 *)"\004_udp"))
10918 {
10919 debugf("DomainEnumQuery: Not a DEQ %##s, label3 mismatch", qname->c);
10920 return(mDNSfalse);
10921 }
10922 debugf("DomainEnumQuery: DEQ %##s, label3 match", qname->c);
10923
10924 debugf("DomainEnumQuery: Question %##s is a Domain Enumeration query", qname->c);
10925
10926 return mDNStrue;
10927}
10928
10929// Note: InterfaceID is the InterfaceID of the question
10930mDNSlocal mDNSBool DNSServerMatch(DNSServer *d, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID)
10931{
10932 // 1) Unscoped questions (NULL InterfaceID) should consider *only* unscoped DNSServers ( DNSServer
10933 // with "scoped" set to kScopeNone)
10934 //
10935 // 2) Scoped questions (non-NULL InterfaceID) should consider *only* scoped DNSServers (DNSServer
10936 // with "scoped" set to kScopeInterfaceId) and their InterfaceIDs should match.
10937 //
10938 // 3) Scoped questions (non-zero ServiceID) should consider *only* scoped DNSServers (DNSServer
10939 // with "scoped" set to kScopeServiceID) and their ServiceIDs should match.
10940 //
10941 // The first condition in the "if" statement checks to see if both the question and the DNSServer are
10942 // unscoped. The question is unscoped only if InterfaceID is zero and ServiceID is -1.
10943 //
10944 // If the first condition fails, following are the possible cases (the notes below are using
10945 // InterfaceID for discussion and the same holds good for ServiceID):
10946 //
10947 // - DNSServer is not scoped, InterfaceID is not NULL - we should skip the current DNSServer entry
10948 // as scoped questions should not pick non-scoped DNSServer entry (Refer to (2) above).
10949 //
10950 // - DNSServer is scoped, InterfaceID is NULL - we should skip the current DNSServer entry as
10951 // unscoped question should not match scoped DNSServer (Refer to (1) above). The InterfaceID check
10952 // would fail in this case.
10953 //
10954 // - DNSServer is scoped and InterfaceID is not NULL - the InterfaceID of the question and the DNSServer
10955 // should match (Refer to (2) above).
10956 //
10957 // Note: mDNSInterface_Unicast is used only by .local unicast questions and are treated as unscoped.
10958 // If a question is scoped both to InterfaceID and ServiceID, the question will be scoped to InterfaceID.
10959
10960 if (((d->scoped == kScopeNone) && ((!InterfaceID && ServiceID == -1) || InterfaceID == mDNSInterface_Unicast)) ||
10961 ((d->scoped == kScopeInterfaceID) && d->interface == InterfaceID) ||
10962 ((d->scoped == kScopeServiceID) && d->serviceID == ServiceID))
10963 {
10964 return mDNStrue;
10965 }
10966 return mDNSfalse;
10967}
10968
10969// Sets all the Valid DNS servers for a question
10970mDNSexport mDNSu32 SetValidDNSServers(mDNS *m, DNSQuestion *question)
10971{
10972 int bestmatchlen = -1, namecount = CountLabels(&question->qname);
10973 DNSServer *curr;
10974 int bettermatch, currcount;
10975 int index = 0;
10976 mDNSu32 timeout = 0;
10977 mDNSBool DEQuery;
10978
10979 question->validDNSServers = zeroOpaque128;
10980 DEQuery = DomainEnumQuery(&question->qname);
10981 for (curr = m->DNSServers; curr; curr = curr->next)
10982 {
10983 debugf("SetValidDNSServers: Parsing DNS server Address %#a (Domain %##s), Scope: %d", &curr->addr, curr->domain.c, curr->scoped);
10984 // skip servers that will soon be deleted
10985 if (curr->flags & DNSServer_FlagDelete)
10986 {
10987 debugf("SetValidDNSServers: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index, &curr->addr, curr->domain.c, curr->scoped);
10988 continue;
10989 }
10990
10991 // This happens normally when you unplug the interface where we reset the interfaceID to mDNSInterface_Any for all
10992 // the DNS servers whose scope match the interfaceID. Few seconds later, we also receive the updated DNS configuration.
10993 // But any questions that has mDNSInterface_Any scope that are started/restarted before we receive the update
10994 // (e.g., CheckSuppressUnusableQuestions is called when interfaces are deregistered with the core) should not
10995 // match the scoped entries by mistake.
10996 //
10997 // Note: DNS configuration change will help pick the new dns servers but currently it does not affect the timeout
10998
10999 // Skip DNSServers that are InterfaceID Scoped but have no valid interfaceid set OR DNSServers that are ServiceID Scoped but have no valid serviceid set
11000 if ((curr->scoped == kScopeInterfaceID && curr->interface == mDNSInterface_Any) || (curr->scoped == kScopeServiceID && curr->serviceID <= 0))
11001 {
11002 LogInfo("SetValidDNSServers: ScopeType[%d] Skipping DNS server %#a (Domain %##s) Interface:[%p] Serviceid:[%d]", curr->scoped, &curr->addr, curr->domain.c, curr->interface, curr->serviceID);
11003 continue;
11004 }
11005
11006 currcount = CountLabels(&curr->domain);
11007 if ((!curr->cellIntf || (!DEQuery && !(question->flags & kDNSServiceFlagsDenyCellular))) &&
11008 (!curr->isExpensive || !(question->flags & kDNSServiceFlagsDenyExpensive)) &&
11009 DNSServerMatch(curr, question->InterfaceID, question->ServiceID))
11010 {
11011 bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen);
11012
11013 // If we found a better match (bettermatch == 1) then clear all the bits
11014 // corresponding to the old DNSServers that we have may set before and start fresh.
11015 // If we find an equal match, then include that DNSServer also by setting the corresponding
11016 // bit
11017 if ((bettermatch == 1) || (bettermatch == 0))
11018 {
11019 bestmatchlen = currcount;
11020 if (bettermatch)
11021 {
11022 debugf("SetValidDNSServers: Resetting all the bits");
11023 question->validDNSServers = zeroOpaque128;
11024 timeout = 0;
11025 }
11026 debugf("SetValidDNSServers: question %##s Setting the bit for DNS server Address %#a (Domain %##s), Scoped:%d index %d,"
11027 " Timeout %d, interface %p", question->qname.c, &curr->addr, curr->domain.c, curr->scoped, index, curr->timeout,
11028 curr->interface);
11029 timeout += curr->timeout;
11030 if (DEQuery)
11031 debugf("DomainEnumQuery: Question %##s, DNSServer %#a, cell %d", question->qname.c, &curr->addr, curr->cellIntf);
11032 bit_set_opaque128(question->validDNSServers, index);
11033 }
11034 }
11035 index++;
11036 }
11037 question->noServerResponse = 0;
11038
11039 debugf("SetValidDNSServers: ValidDNSServer bits 0x%x%x%x%x for question %p %##s (%s)",
11040 question->validDNSServers.l[3], question->validDNSServers.l[2], question->validDNSServers.l[1], question->validDNSServers.l[0], question, question->qname.c, DNSTypeName(question->qtype));
11041 // If there are no matching resolvers, then use the default timeout value.
11042 // For ProxyQuestion, shorten the timeout so that dig does not timeout on us in case of no response.
11043 return ((question->ProxyQuestion || question->ValidatingResponse) ? DEFAULT_UDNSSEC_TIMEOUT : timeout ? timeout : DEFAULT_UDNS_TIMEOUT);
11044}
11045
11046// Get the Best server that matches a name. If you find penalized servers, look for the one
11047// that will come out of the penalty box soon
11048mDNSlocal DNSServer *GetBestServer(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID, mDNSOpaque128 validBits,
11049 int *selected, mDNSBool nameMatch)
11050{
11051 DNSServer *curmatch = mDNSNULL;
11052 int bestmatchlen = -1, namecount = name ? CountLabels(name) : 0;
11053 DNSServer *curr;
11054 mDNSs32 bestPenaltyTime, currPenaltyTime;
11055 int bettermatch, currcount;
11056 int index = 0;
11057 int currindex = -1;
11058
11059 debugf("GetBestServer: ValidDNSServer bits 0x%x%x", validBits.l[1], validBits.l[0]);
11060 bestPenaltyTime = DNSSERVER_PENALTY_TIME + 1;
11061 for (curr = m->DNSServers; curr; curr = curr->next)
11062 {
11063 // skip servers that will soon be deleted
11064 if (curr->flags & DNSServer_FlagDelete)
11065 {
11066 debugf("GetBestServer: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index, &curr->addr, curr->domain.c, curr->scoped);
11067 continue;
11068 }
11069
11070 // Check if this is a valid DNSServer
11071 if (!bit_get_opaque64(validBits, index))
11072 {
11073 debugf("GetBestServer: continuing for index %d", index);
11074 index++;
11075 continue;
11076 }
11077
11078 currcount = CountLabels(&curr->domain);
11079 currPenaltyTime = PenaltyTimeForServer(m, curr);
11080
11081 debugf("GetBestServer: Address %#a (Domain %##s), PenaltyTime(abs) %d, PenaltyTime(rel) %d",
11082 &curr->addr, curr->domain.c, curr->penaltyTime, currPenaltyTime);
11083
11084 // If there are multiple best servers for a given question, we will pick the first one
11085 // if none of them are penalized. If some of them are penalized in that list, we pick
11086 // the least penalized one. BetterMatchForName walks through all best matches and
11087 // "currPenaltyTime < bestPenaltyTime" check lets us either pick the first best server
11088 // in the list when there are no penalized servers and least one among them
11089 // when there are some penalized servers.
11090
11091 if (DNSServerMatch(curr, InterfaceID, ServiceID))
11092 {
11093
11094 // If we know that all the names are already equally good matches, then skip calling BetterMatchForName.
11095 // This happens when we initially walk all the DNS servers and set the validity bit on the question.
11096 // Actually we just need PenaltyTime match, but for the sake of readability we just skip the expensive
11097 // part and still do some redundant steps e.g., InterfaceID match
11098
11099 if (nameMatch)
11100 bettermatch = BetterMatchForName(name, namecount, &curr->domain, currcount, bestmatchlen);
11101 else
11102 bettermatch = 0;
11103
11104 // If we found a better match (bettermatch == 1) then we don't need to
11105 // compare penalty times. But if we found an equal match, then we compare
11106 // the penalty times to pick a better match
11107
11108 if ((bettermatch == 1) || ((bettermatch == 0) && currPenaltyTime < bestPenaltyTime))
11109 {
11110 currindex = index;
11111 curmatch = curr;
11112 bestmatchlen = currcount;
11113 bestPenaltyTime = currPenaltyTime;
11114 }
11115 }
11116 index++;
11117 }
11118 if (selected) *selected = currindex;
11119 return curmatch;
11120}
11121
11122// Look up a DNS Server, matching by name and InterfaceID
11123mDNSlocal DNSServer *GetServerForName(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID)
11124{
11125 DNSServer *curmatch = mDNSNULL;
11126 char *ifname = mDNSNULL; // for logging purposes only
11127 mDNSOpaque128 allValid;
11128
11129 if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly))
11130 InterfaceID = mDNSNULL;
11131
11132 if (InterfaceID) ifname = InterfaceNameForID(m, InterfaceID);
11133
11134 // By passing in all ones, we make sure that every DNS server is considered
11135 allValid.l[0] = allValid.l[1] = allValid.l[2] = allValid.l[3] = 0xFFFFFFFF;
11136
11137 curmatch = GetBestServer(m, name, InterfaceID, ServiceID, allValid, mDNSNULL, mDNStrue);
11138
11139 if (curmatch != mDNSNULL)
11140 LogInfo("GetServerForName: DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s", &curmatch->addr,
11141 mDNSVal16(curmatch->port), (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None",
11142 InterfaceID, name);
11143 else
11144 LogInfo("GetServerForName: no DNS server (Scope %s:%p) found for name %##s", ifname ? ifname : "None", InterfaceID, name);
11145
11146 return(curmatch);
11147}
11148
11149// Look up a DNS Server for a question within its valid DNSServer bits
11150mDNSexport DNSServer *GetServerForQuestion(mDNS *m, DNSQuestion *question)
11151{
11152 DNSServer *curmatch = mDNSNULL;
11153 char *ifname = mDNSNULL; // for logging purposes only
11154 mDNSInterfaceID InterfaceID = question->InterfaceID;
11155 const domainname *name = &question->qname;
11156 int currindex;
11157
11158 if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly))
11159 InterfaceID = mDNSNULL;
11160
11161 if (InterfaceID)
11162 ifname = InterfaceNameForID(m, InterfaceID);
11163
11164 if (!mDNSOpaque128IsZero(&question->validDNSServers))
11165 {
11166 curmatch = GetBestServer(m, name, InterfaceID, question->ServiceID, question->validDNSServers, &currindex, mDNSfalse);
11167 if (currindex != -1)
11168 bit_clr_opaque128(question->validDNSServers, currindex);
11169 }
11170
11171 if (curmatch != mDNSNULL)
11172 {
11173 LogInfo("GetServerForQuestion: %p DNS server (%p) %#a:%d (Penalty Time Left %d) (Scope %s:%p:%d) found for name %##s (%s)",
11174 question, curmatch, &curmatch->addr, mDNSVal16(curmatch->port),
11175 (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None",
11176 InterfaceID, question->ServiceID, name, DNSTypeName(question->qtype));
11177 }
11178 else
11179 {
11180 LogInfo("GetServerForQuestion: %p no DNS server (Scope %s:%p:%d) found for name %##s (%s)",
11181 question, ifname ? ifname : "None", InterfaceID, question->ServiceID, name, DNSTypeName(question->qtype));
11182 }
11183
11184 return(curmatch);
11185}
11186
11187
11188#define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \
11189 (mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort)))
11190
11191// Called in normal client context (lock not held)
11192mDNSlocal void LLQNATCallback(mDNS *m, NATTraversalInfo *n)
11193{
11194 DNSQuestion *q;
11195 mDNS_Lock(m);
11196 LogInfo("LLQNATCallback external address:port %.4a:%u, NAT result %d", &n->ExternalAddress, mDNSVal16(n->ExternalPort), n->Result);
11197 n->clientContext = mDNSNULL; // we received at least one callback since starting this NAT-T
11198 for (q = m->Questions; q; q=q->next)
11199 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived)
11200 startLLQHandshake(m, q); // If ExternalPort is zero, will do StartLLQPolling instead
11201#if APPLE_OSX_mDNSResponder
11202 UpdateAutoTunnelDomainStatuses(m);
11203#endif
11204 mDNS_Unlock(m);
11205}
11206
11207mDNSlocal mDNSBool IsPrivateDomain(mDNS *const m, DNSQuestion *q)
11208{
11209 DomainAuthInfo *AuthInfo;
11210 // Skip Private domains as we have special addresses to get the hosts in the Private domain
11211 AuthInfo = GetAuthInfoForName_internal(m, &q->qname);
11212 if (AuthInfo && !AuthInfo->deltime && AuthInfo->AutoTunnel)
11213 {
11214 debugf("IsPrivateDomain: %##s true", q->qname.c);
11215 return mDNStrue;
11216 }
11217 else
11218 {
11219 debugf("IsPrivateDomain: %##s false", q->qname.c);
11220 return mDNSfalse;
11221 }
11222}
11223
11224// This function takes the DNSServer as a separate argument because sometimes the
11225// caller has not yet assigned the DNSServer, but wants to evaluate the SuppressQuery
11226// status before switching to it.
11227mDNSlocal mDNSBool ShouldSuppressUnicastQuery(mDNS *const m, DNSQuestion *q, DNSServer *d)
11228{
11229 // Some callers don't check for the qtype
11230 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA)
11231 {
11232 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type", q->qname.c, DNSTypeName(q->qtype));
11233 return mDNSfalse;
11234 }
11235
11236 // Private domains are exempted irrespective of what the DNSServer says
11237 if (IsPrivateDomain(m, q))
11238 {
11239 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, Private Domain", q->qname.c, DNSTypeName(q->qtype));
11240 return mDNSfalse;
11241 }
11242
11243 if (!d)
11244 {
11245 LogInfo("ShouldSuppressUnicastQuery: Query suppressed for %##s, qtype %s, as the DNS server is NULL", q->qname.c, DNSTypeName(q->qtype));
11246 return mDNStrue;
11247 }
11248
11249 // Check if the DNS Configuration allows A/AAAA queries to be sent
11250 if ((q->qtype == kDNSType_A) && (d->req_A))
11251 {
11252 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, DNSServer %##s %#a:%d allows A queries", q->qname.c,
11253 DNSTypeName(q->qtype), d->domain.c, &d->addr, mDNSVal16(d->port));
11254 return mDNSfalse;
11255 }
11256 if ((q->qtype == kDNSType_AAAA) && (d->req_AAAA))
11257 {
11258 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, DNSServer %##s %#a:%d allows AAAA queries", q->qname.c,
11259 DNSTypeName(q->qtype), d->domain.c, &d->addr, mDNSVal16(d->port));
11260 return mDNSfalse;
11261 }
11262#if USE_DNS64
11263 if (DNS64IsQueryingARecord(q->dns64.state))
11264 {
11265 LogInfo("ShouldSuppressUnicastQuery: DNS64 query not suppressed for %##s, qtype %s", q->qname.c, DNSTypeName(q->qtype));
11266 return mDNSfalse;
11267 }
11268#endif
11269
11270 LogInfo("ShouldSuppressUnicastQuery: Query suppressed for %##s, qtype %s, since DNS Configuration does not allow (req_A is %s and req_AAAA is %s)",
11271 q->qname.c, DNSTypeName(q->qtype), d->req_A ? "true" : "false", d->req_AAAA ? "true" : "false");
11272
11273 return mDNStrue;
11274}
11275
11276mDNSlocal mDNSBool ShouldSuppressDotLocalQuery(mDNS *const m, DNSQuestion *q)
11277{
11278 NetworkInterfaceInfo *intf;
11279 AuthRecord *rr;
11280 mDNSBool ret;
11281
11282 // Check to see if there is at least one interface other than loopback and don't suppress
11283 // .local questions if you find one. If we have at least one interface, it means that
11284 // we can send unicast queries for the .local name and we don't want to suppress
11285 // multicast in that case as upper layers don't know how to handle if we return a
11286 // negative response for multicast followed by a positive response for unicast.
11287 //
11288 // Note: we used to check for multicast capable interfaces instead of just any interface
11289 // present. That did not work in the case where we have a valid interface for unicast
11290 // but not multicast capable e.g., cellular, as we ended up delivering a negative response
11291 // first and the upper layer did not wait for the positive response that came later.
11292 for (intf = m->HostInterfaces; intf; intf = intf->next)
11293 {
11294 if (intf->InterfaceActive && !intf->Loopback)
11295 {
11296 LogInfo("ShouldSuppressDotLocalQuery: Found interface %s, not suppressing", intf->ifname);
11297 return mDNSfalse;
11298 }
11299 }
11300
11301 // 1. If we find a LocalOnly or P2P record answering this question, then don't suppress it.
11302 // Set m->CurrentQuestion as it is required by AnswerQuestionWithLORecord.
11303 m->CurrentQuestion = q;
11304 ret = AnswerQuestionWithLORecord(m, q, mDNStrue);
11305 m->CurrentQuestion = mDNSNULL;
11306
11307 if (ret)
11308 {
11309 LogInfo("ShouldSuppressDotLocalQuery: Found LocalOnly record for %##s (%s), not suppressing", q->qname.c,
11310 DNSTypeName(q->qtype));
11311 return mDNSfalse;
11312 }
11313
11314 // 2. If we find a local AuthRecord answering this question, then don't suppress it.
11315 for (rr = m->ResourceRecords; rr; rr = rr->next)
11316 {
11317 if (ResourceRecordAnswersQuestion(&rr->resrec, q))
11318 {
11319 LogInfo("ShouldSuppressDotLocalQuery: Found resource record %s for %##s (%s) not suppressing", ARDisplayString(m, rr),
11320 q->qname.c, DNSTypeName(q->qtype));
11321 return mDNSfalse;
11322 }
11323 }
11324 return mDNStrue;
11325}
11326
11327mDNSlocal mDNSBool ShouldSuppressQuery(mDNS *const m, DNSQuestion *q)
11328{
11329 if (q->InterfaceID == mDNSInterface_LocalOnly)
11330 {
11331 LogInfo("ShouldSuppressQuery: LocalOnly query not suppressed for %##s, qtype %s", q->qname.c, DNSTypeName(q->qtype));
11332 return mDNSfalse;
11333 }
11334
11335 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA)
11336 {
11337 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type", q->qname.c, DNSTypeName(q->qtype));
11338 return mDNSfalse;
11339 }
11340
11341 // We still want the ability to be able to listen to the local services and hence
11342 // don't fail .local query if we have local records that can potentially answer
11343 // the question.
11344 if (q->InterfaceID != mDNSInterface_Unicast && IsLocalDomain(&q->qname))
11345 {
11346 if (!ShouldSuppressDotLocalQuery(m, q))
11347 {
11348 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local question", q->qname.c, DNSTypeName(q->qtype));
11349 return mDNSfalse;
11350 }
11351 else
11352 {
11353 LogInfo("ShouldSuppressQuery: Query suppressed for %##s, qtype %s, Local question", q->qname.c, DNSTypeName(q->qtype));
11354 return mDNStrue;
11355 }
11356 }
11357
11358 return (ShouldSuppressUnicastQuery(m, q, q->qDNSServer));
11359}
11360
11361mDNSlocal void CacheRecordRmvEventsForCurrentQuestion(mDNS *const m, DNSQuestion *q)
11362{
11363 CacheRecord *rr;
11364 CacheGroup *cg;
11365
11366 cg = CacheGroupForName(m, q->qnamehash, &q->qname);
11367 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
11368 {
11369 // Don't deliver RMV events for negative records
11370 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative)
11371 {
11372 LogInfo("CacheRecordRmvEventsForCurrentQuestion: CacheRecord %s Suppressing RMV events for question %p %##s (%s), CRActiveQuestion %p, CurrentAnswers %d",
11373 CRDisplayString(m, rr), q, q->qname.c, DNSTypeName(q->qtype), rr->CRActiveQuestion, q->CurrentAnswers);
11374 continue;
11375 }
11376
11377 if (SameNameRecordAnswersQuestion(&rr->resrec, q))
11378 {
11379 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Calling AnswerCurrentQuestionWithResourceRecord (RMV) for question %##s using resource record %s LocalAnswers %d",
11380 q->qname.c, CRDisplayString(m, rr), q->LOAddressAnswers);
11381
11382 q->CurrentAnswers--;
11383 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--;
11384 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--;
11385
11386 if (rr->CRActiveQuestion == q)
11387 {
11388 DNSQuestion *qptr;
11389 // If this was the active question for this cache entry, it was the one that was
11390 // responsible for keeping the cache entry fresh when the cache entry was reaching
11391 // its expiry. We need to handover the responsibility to someone else. Otherwise,
11392 // when the cache entry is about to expire, we won't find an active question
11393 // (pointed by CRActiveQuestion) to refresh the cache.
11394 for (qptr = m->Questions; qptr; qptr=qptr->next)
11395 if (qptr != q && ActiveQuestion(qptr) && ResourceRecordAnswersQuestion(&rr->resrec, qptr))
11396 break;
11397
11398 if (qptr)
11399 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Updating CRActiveQuestion to %p for cache record %s, "
11400 "Original question CurrentAnswers %d, new question CurrentAnswers %d, SuppressUnusable %d, SuppressQuery %d",
11401 qptr, CRDisplayString(m,rr), q->CurrentAnswers, qptr->CurrentAnswers, qptr->SuppressUnusable, qptr->SuppressQuery);
11402
11403 rr->CRActiveQuestion = qptr; // Question used to be active; new value may or may not be null
11404 if (!qptr) m->rrcache_active--; // If no longer active, decrement rrcache_active count
11405 }
11406 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv);
11407 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
11408 }
11409 }
11410}
11411
11412mDNSlocal mDNSBool IsQuestionNew(mDNS *const m, DNSQuestion *question)
11413{
11414 DNSQuestion *q;
11415 for (q = m->NewQuestions; q; q = q->next)
11416 if (q == question) return mDNStrue;
11417 return mDNSfalse;
11418}
11419
11420mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q)
11421{
11422 AuthRecord *rr;
11423 AuthGroup *ag;
11424
11425 if (m->CurrentQuestion)
11426 LogMsg("LocalRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)",
11427 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
11428
11429 if (IsQuestionNew(m, q))
11430 {
11431 LogInfo("LocalRecordRmvEventsForQuestion: New Question %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
11432 return mDNStrue;
11433 }
11434 m->CurrentQuestion = q;
11435 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname);
11436 if (ag)
11437 {
11438 for (rr = ag->members; rr; rr=rr->next)
11439 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME
11440 if (UniqueLocalOnlyRecord(rr) && LocalOnlyRecordAnswersQuestion(rr, q))
11441 {
11442 LogInfo("LocalRecordRmvEventsForQuestion: Delivering possible Rmv events with record %s",
11443 ARDisplayString(m, rr));
11444 if (q->CurrentAnswers <= 0 || q->LOAddressAnswers <= 0)
11445 {
11446 LogMsg("LocalRecordRmvEventsForQuestion: ERROR!! CurrentAnswers or LOAddressAnswers is zero %p %##s"
11447 " (%s) CurrentAnswers %d, LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype),
11448 q->CurrentAnswers, q->LOAddressAnswers);
11449 continue;
11450 }
11451 AnswerLocalQuestionWithLocalAuthRecord(m, rr, QC_rmv); // MUST NOT dereference q again
11452 if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; }
11453 }
11454 }
11455 m->CurrentQuestion = mDNSNULL;
11456 return mDNStrue;
11457}
11458
11459// Returns false if the question got deleted while delivering the RMV events
11460// The caller should handle the case
11461mDNSexport mDNSBool CacheRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q)
11462{
11463 if (m->CurrentQuestion)
11464 LogMsg("CacheRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)",
11465 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
11466
11467 // If it is a new question, we have not delivered any ADD events yet. So, don't deliver RMV events.
11468 // If this question was answered using local auth records, then you can't deliver RMVs using cache
11469 if (!IsQuestionNew(m, q) && !q->LOAddressAnswers)
11470 {
11471 m->CurrentQuestion = q;
11472 CacheRecordRmvEventsForCurrentQuestion(m, q);
11473 if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; }
11474 m->CurrentQuestion = mDNSNULL;
11475 }
11476 else { LogInfo("CacheRecordRmvEventsForQuestion: Question %p %##s (%s) is a new question", q, q->qname.c, DNSTypeName(q->qtype)); }
11477 return mDNStrue;
11478}
11479
11480mDNSlocal void SuppressStatusChanged(mDNS *const m, DNSQuestion *q, DNSQuestion **restart)
11481{
11482 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero
11483 // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before
11484 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers)
11485 if (q->SuppressQuery)
11486 {
11487 q->SuppressQuery = mDNSfalse;
11488 if (!CacheRecordRmvEventsForQuestion(m, q))
11489 {
11490 LogInfo("SuppressStatusChanged: Question deleted while delivering RMV events from cache");
11491 return;
11492 }
11493 q->SuppressQuery = mDNStrue;
11494 }
11495
11496 // SuppressUnusable does not affect questions that are answered from the local records (/etc/hosts)
11497 // and SuppressQuery status does not mean anything for these questions. As we are going to stop the
11498 // question below, we need to deliver the RMV events so that the ADDs that will be delivered during
11499 // the restart will not be a duplicate ADD
11500 if (!LocalRecordRmvEventsForQuestion(m, q))
11501 {
11502 LogInfo("SuppressStatusChanged: Question deleted while delivering RMV events from Local AuthRecords");
11503 return;
11504 }
11505
11506 // There are two cases here.
11507 //
11508 // 1. Previously it was suppressed and now it is not suppressed, restart the question so
11509 // that it will start as a new question. Note that we can't just call ActivateUnicastQuery
11510 // because when we get the response, if we had entries in the cache already, it will not answer
11511 // this question if the cache entry did not change. Hence, we need to restart
11512 // the query so that it can be answered from the cache.
11513 //
11514 // 2. Previously it was not suppressed and now it is suppressed. We need to restart the questions
11515 // so that we redo the duplicate checks in mDNS_StartQuery_internal. A SuppressUnusable question
11516 // is a duplicate of non-SuppressUnusable question if it is not suppressed (SuppressQuery is false).
11517 // A SuppressUnusable question is not a duplicate of non-SuppressUnusable question if it is suppressed
11518 // (SuppressQuery is true). The reason for this is that when a question is suppressed, we want an
11519 // immediate response and not want to be blocked behind a question that is querying DNS servers. When
11520 // the question is not suppressed, we don't want two active questions sending packets on the wire.
11521 // This affects both efficiency and also the current design where there is only one active question
11522 // pointed to from a cache entry.
11523 //
11524 // We restart queries in a two step process by first calling stop and build a temporary list which we
11525 // will restart at the end. The main reason for the two step process is to handle duplicate questions.
11526 // If there are duplicate questions, calling stop inherits the values from another question on the list (which
11527 // will soon become the real question) including q->ThisQInterval which might be zero if it was
11528 // suppressed before. At the end when we have restarted all questions, none of them is active as each
11529 // inherits from one another and we need to reactivate one of the questions here which is a little hacky.
11530 //
11531 // It is much cleaner and less error prone to build a list of questions and restart at the end.
11532
11533 LogInfo("SuppressStatusChanged: Stop question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
11534 mDNS_StopQuery_internal(m, q);
11535 q->next = *restart;
11536 *restart = q;
11537}
11538
11539// The caller should hold the lock
11540mDNSexport void CheckSuppressUnusableQuestions(mDNS *const m)
11541{
11542 DNSQuestion *q;
11543 DNSQuestion *restart = mDNSNULL;
11544
11545 // We look through all questions including new questions. During network change events,
11546 // we potentially restart questions here in this function that ends up as new questions,
11547 // which may be suppressed at this instance. Before it is handled we get another network
11548 // event that changes the status e.g., address becomes available. If we did not process
11549 // new questions, we would never change its SuppressQuery status.
11550 //
11551 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the
11552 // application callback can potentially stop the current question (detected by CurrentQuestion) or
11553 // *any* other question which could be the next one that we may process here. RestartQuestion
11554 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal
11555 // if the "next" question is stopped while the CurrentQuestion is stopped
11556 if (m->RestartQuestion)
11557 LogMsg("CheckSuppressUnusableQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)",
11558 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype));
11559 m->RestartQuestion = m->Questions;
11560 while (m->RestartQuestion)
11561 {
11562 q = m->RestartQuestion;
11563 m->RestartQuestion = q->next;
11564 if (q->SuppressUnusable)
11565 {
11566 mDNSBool old = q->SuppressQuery;
11567 q->SuppressQuery = ShouldSuppressQuery(m, q);
11568 if (q->SuppressQuery != old)
11569 {
11570 // Previously it was not suppressed, Generate RMV events for the ADDs that we might have delivered before
11571 // followed by a negative cache response. Temporarily turn off suppression so that
11572 // AnswerCurrentQuestionWithResourceRecord can answer the question
11573 SuppressStatusChanged(m, q, &restart);
11574 }
11575 }
11576 }
11577 while (restart)
11578 {
11579 q = restart;
11580 restart = restart->next;
11581 q->next = mDNSNULL;
11582 LogInfo("CheckSuppressUnusableQuestions: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
11583 mDNS_StartQuery_internal(m, q);
11584 }
11585}
11586
11587mDNSlocal void RestartUnicastQuestions(mDNS *const m)
11588{
11589 DNSQuestion *q;
11590 DNSQuestion *restart = mDNSNULL;
11591
11592 if (m->RestartQuestion)
11593 LogMsg("RestartUnicastQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)",
11594 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype));
11595 m->RestartQuestion = m->Questions;
11596 while (m->RestartQuestion)
11597 {
11598 q = m->RestartQuestion;
11599 m->RestartQuestion = q->next;
11600 if (q->Restart)
11601 {
11602 if (mDNSOpaque16IsZero(q->TargetQID))
11603 LogMsg("RestartUnicastQuestions: ERROR!! Restart set for multicast question %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
11604
11605 q->Restart = 0;
11606 SuppressStatusChanged(m, q, &restart);
11607 }
11608 }
11609 while (restart)
11610 {
11611 q = restart;
11612 restart = restart->next;
11613 q->next = mDNSNULL;
11614 LogInfo("RestartUnicastQuestions: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
11615 mDNS_StartQuery_internal(m, q);
11616 }
11617}
11618
11619
11620// ValidateParameters() is called by mDNS_StartQuery_internal() to check the client parameters of
11621// DNS Question that are already set by the client before calling mDNS_StartQuery()
11622mDNSlocal mStatus ValidateParameters(mDNS *const m, DNSQuestion *const question)
11623{
11624
11625 if (question->Target.type && !ValidQuestionTarget(question))
11626 {
11627 LogMsg("ValidateParameters: Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery? for question %##s)",
11628 question->Target.type, mDNSVal16(question->TargetPort), question->qname.c);
11629 question->Target.type = mDNSAddrType_None;
11630 }
11631
11632 // If no question->Target specified, clear TargetPort
11633 if (!question->Target.type)
11634 question->TargetPort = zeroIPPort;
11635
11636 if (!ValidateDomainName(&question->qname))
11637 {
11638 LogMsg("ValidateParameters: Attempt to start query with invalid qname %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
11639 return(mStatus_Invalid);
11640 }
11641
11642 // If this question is referencing a specific interface, verify it exists
11643 if (question->InterfaceID && !LocalOnlyOrP2PInterface(question->InterfaceID) && question->InterfaceID != mDNSInterface_Unicast)
11644 {
11645 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, question->InterfaceID);
11646 if (!intf)
11647 LogInfo("ValidateParameters: Note: InterfaceID %d for question %##s (%s) not currently found in active interface list",
11648 IID(question->InterfaceID), question->qname.c, DNSTypeName(question->qtype));
11649 }
11650
11651 return(mStatus_NoError);
11652}
11653
11654// InitDNSConfig() is called by InitCommonState() to initialize the DNS configuration of the Question.
11655// These are a subset of the internal uDNS fields. Must be done before ShouldSuppressQuery() & mDNS_PurgeForQuestion()
11656mDNSlocal void InitDNSConfig(mDNS *const m, DNSQuestion *const question)
11657{
11658 // First reset all DNS Configuration
11659 question->qDNSServer = mDNSNULL;
11660 question->validDNSServers = zeroOpaque128;
11661 question->triedAllServersOnce = 0;
11662 question->noServerResponse = 0;
11663 question->StopTime = (question->TimeoutQuestion) ? question->StopTime : 0;
11664#if AWD_METRICS
11665 mDNSPlatformMemZero(&question->metrics, sizeof(question->metrics));
11666#endif
11667
11668 // Need not initialize the DNS Configuration for Local Only OR P2P Questions when timeout not specified
11669 if (LocalOnlyOrP2PInterface(question->InterfaceID) && !question->TimeoutQuestion)
11670 return;
11671 // Proceed to initialize DNS Configuration (some are set in SetValidDNSServers())
11672 if (!mDNSOpaque16IsZero(question->TargetQID))
11673 {
11674 mDNSu32 timeout = SetValidDNSServers(m, question);
11675 // We set the timeout value the first time mDNS_StartQuery_internal is called for a question.
11676 // So if a question is restarted when a network change occurs, the StopTime is not reset.
11677 // Note that we set the timeout for all questions. If this turns out to be a duplicate,
11678 // it gets a full timeout value even if the original question times out earlier.
11679 if (question->TimeoutQuestion && !question->StopTime)
11680 {
11681 question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond);
11682 LogInfo("InitDNSConfig: Setting StopTime on the uDNS question %p %##s (%s)", question, question->qname.c, DNSTypeName(question->qtype));
11683 }
11684
11685 question->qDNSServer = GetServerForQuestion(m, question);
11686 LogInfo("InitDNSConfig: question %p %##s (%s) Timeout %d, DNS Server %#a:%d",
11687 question, question->qname.c, DNSTypeName(question->qtype), timeout,
11688 question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL,
11689 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort));
11690 }
11691 else if (question->TimeoutQuestion && !question->StopTime)
11692 {
11693 // If the question is to be timed out and its a multicast, local-only or P2P case,
11694 // then set it's stop time.
11695 mDNSu32 timeout = LocalOnlyOrP2PInterface(question->InterfaceID) ?
11696 DEFAULT_LO_OR_P2P_TIMEOUT : GetTimeoutForMcastQuestion(m, question);
11697 question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond);
11698 LogInfo("InitDNSConfig: Setting StopTime on question %p %##s (%s)", question, question->qname.c, DNSTypeName(question->qtype));
11699 }
11700 // Set StopTime here since it is a part of DNS Configuration
11701 if (question->StopTime)
11702 SetNextQueryStopTime(m, question);
11703 // Don't call SetNextQueryTime() if a LocalOnly OR P2P Question since those questions
11704 // will never be transmitted on the wire.
11705 if (!(LocalOnlyOrP2PInterface(question->InterfaceID)))
11706 SetNextQueryTime(m,question);
11707}
11708
11709// InitCommonState() is called by mDNS_StartQuery_internal() to initialize the common(uDNS/mDNS) internal
11710// state fields of the DNS Question. These are independent of the Client layer.
11711mDNSlocal mDNSBool InitCommonState(mDNS *const m, DNSQuestion *const question)
11712{
11713 mDNSBool purge;
11714 int i;
11715 mDNSBool isBlocked = mDNSfalse;
11716
11717 // Note: In the case where we already have the answer to this question in our cache, that may be all the client
11718 // wanted, and they may immediately cancel their question. In this case, sending an actual query on the wire would
11719 // be a waste. For that reason, we schedule our first query to go out in half a second (InitialQuestionInterval).
11720 // If AnswerNewQuestion() finds that we have *no* relevant answers currently in our cache, then it will accelerate
11721 // that to go out immediately.
11722 question->next = mDNSNULL;
11723 // ThisQInterval should be initialized before any memory allocations occur. If malloc
11724 // debugging is turned on within mDNSResponder (see mDNSDebug.h for details) it validates
11725 // the question list to check if ThisQInterval is negative which means the question has been
11726 // stopped and can't be on the list. The question is already on the list and ThisQInterval
11727 // can be negative if the caller just stopped it and starting it again. Hence, it always has to
11728 // be initialized. CheckForSoonToExpireRecords below prints the cache records when logging is
11729 // turned ON which can allocate memory e.g., base64 encoding, in the case of DNSSEC.
11730 question->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question
11731 question->qnamehash = DomainNameHashValue(&question->qname);
11732 question->DelayAnswering = CheckForSoonToExpireRecords(m, &question->qname, question->qnamehash, &purge);
11733 question->LastQTime = m->timenow;
11734 question->ExpectUnicastResp = 0;
11735 question->LastAnswerPktNum = m->PktNum;
11736 question->RecentAnswerPkts = 0;
11737 question->CurrentAnswers = 0;
11738
11739#if APPLE_OSX_mDNSResponder
11740
11741// Initial browse threshold used by Finder.
11742#define mDNSFinderBrowseThreshold 20
11743
11744 // Set the threshold at which we move to a passive browse state,
11745 // not actively sending queries.
11746 if (question->flags & kDNSServiceFlagsThresholdOne)
11747 question->BrowseThreshold = 1;
11748 else if (question->flags & kDNSServiceFlagsThresholdFinder)
11749 question->BrowseThreshold = mDNSFinderBrowseThreshold;
11750 else
11751 question->BrowseThreshold = 0;
11752
11753#else // APPLE_OSX_mDNSResponder
11754 question->BrowseThreshold = 0;
11755#endif // APPLE_OSX_mDNSResponder
11756 question->CachedAnswerNeedsUpdate = mDNSfalse;
11757
11758 question->LargeAnswers = 0;
11759 question->UniqueAnswers = 0;
11760 question->LOAddressAnswers = 0;
11761 question->FlappingInterface1 = mDNSNULL;
11762 question->FlappingInterface2 = mDNSNULL;
11763
11764 // if kDNSServiceFlagsServiceIndex flag is SET by the client, then do NOT call mDNSPlatformGetDNSRoutePolicy()
11765 // since we would already have the question->ServiceID in that case.
11766 if (!(question->flags & kDNSServiceFlagsServiceIndex))
11767 {
11768#if APPLE_OSX_mDNSResponder
11769 mDNSPlatformGetDNSRoutePolicy(question, &isBlocked);
11770#else
11771 question->ServiceID = -1;
11772#endif
11773 }
11774 else
11775 LogInfo("InitCommonState: Query for %##s (%s), PID[%d], EUID[%d], ServiceID[%d] is already set by client", question->qname.c,
11776 DNSTypeName(question->qtype), question->pid, question->euid, question->ServiceID);
11777
11778 InitDNSConfig(m, question);
11779
11780 question->AuthInfo = GetAuthInfoForQuestion(m, question);
11781 question->SuppressQuery = 0;
11782 if (question->SuppressUnusable)
11783 question->SuppressQuery = ShouldSuppressQuery(m, question);
11784
11785 // If ServiceID is 0 or the policy disallows making DNS requests,
11786 // set DisallowPID
11787 question->DisallowPID = (question->ServiceID == 0 || isBlocked);
11788 if (question->DisallowPID)
11789 LogInfo("InitCommonState: Query suppressed for %##s (%s), PID %d/ServiceID %d not allowed", question->qname.c,
11790 DNSTypeName(question->qtype), question->pid, question->ServiceID);
11791
11792 question->NextInDQList = mDNSNULL;
11793 question->SendQNow = mDNSNULL;
11794 question->SendOnAll = mDNSfalse;
11795 question->RequestUnicast = kDefaultRequestUnicastCount;
11796
11797#if APPLE_OSX_mDNSResponder
11798 // Set the QU bit in the first query for the following options.
11799 if ((question->flags & kDNSServiceFlagsUnicastResponse) || (question->flags & kDNSServiceFlagsThresholdFinder))
11800 {
11801 question->RequestUnicast = SET_QU_IN_FIRST_QUERY;
11802 LogInfo("InitCommonState: setting RequestUnicast = %d for %##s (%s)", question->RequestUnicast, question->qname.c,
11803 DNSTypeName(question->qtype));
11804 }
11805#endif // APPLE_OSX_mDNSResponder
11806
11807 question->LastQTxTime = m->timenow;
11808 question->CNAMEReferrals = 0;
11809
11810 question->WakeOnResolveCount = 0;
11811 if (question->WakeOnResolve)
11812 {
11813 question->WakeOnResolveCount = InitialWakeOnResolveCount;
11814 purge = mDNStrue;
11815 }
11816
11817 for (i=0; i<DupSuppressInfoSize; i++)
11818 question->DupSuppress[i].InterfaceID = mDNSNULL;
11819
11820 question->Restart = 0;
11821
11822 debugf("InitCommonState: Question %##s (%s) Interface %p Now %d Send in %d Answer in %d (%p) %s (%p)",
11823 question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, m->timenow,
11824 NextQSendTime(question) - m->timenow,
11825 question->DelayAnswering ? question->DelayAnswering - m->timenow : 0,
11826 question, question->DuplicateOf ? "duplicate of" : "not duplicate", question->DuplicateOf);
11827
11828 if (question->DelayAnswering)
11829 LogInfo("InitCommonState: Delaying answering for %d ticks while cache stabilizes for %##s (%s)",
11830 question->DelayAnswering - m->timenow, question->qname.c, DNSTypeName(question->qtype));
11831
11832 return(purge);
11833}
11834
11835// Excludes the DNS Config fields which are already handled by InitDNSConfig()
11836mDNSlocal void InitWABState(DNSQuestion *const question)
11837{
11838 // We'll create our question->LocalSocket on demand, if needed.
11839 // We won't need one for duplicate questions, or from questions answered immediately out of the cache.
11840 // We also don't need one for LLQs because (when we're using NAT) we want them all to share a single
11841 // NAT mapping for receiving inbound add/remove events.
11842 question->LocalSocket = mDNSNULL;
11843 question->unansweredQueries = 0;
11844 question->nta = mDNSNULL;
11845 question->servAddr = zeroAddr;
11846 question->servPort = zeroIPPort;
11847 question->tcp = mDNSNULL;
11848 question->NoAnswer = NoAnswer_Normal;
11849}
11850
11851mDNSlocal void InitLLQNATState(mDNS *const m)
11852{
11853 // If we don't have our NAT mapping active, start it now
11854 if (!m->LLQNAT.clientCallback)
11855 {
11856 m->LLQNAT.Protocol = NATOp_MapUDP;
11857 m->LLQNAT.IntPort = m->UnicastPort4;
11858 m->LLQNAT.RequestedPort = m->UnicastPort4;
11859 m->LLQNAT.clientCallback = LLQNATCallback;
11860 m->LLQNAT.clientContext = (void*)1; // Means LLQ NAT Traversal just started
11861 mDNS_StartNATOperation_internal(m, &m->LLQNAT);
11862 }
11863}
11864
11865mDNSlocal void InitLLQState(DNSQuestion *const question)
11866{
11867 question->state = LLQ_InitialRequest;
11868 question->ReqLease = 0;
11869 question->expire = 0;
11870 question->ntries = 0;
11871 question->id = zeroOpaque64;
11872}
11873
11874#ifdef DNS_PUSH_ENABLED
11875mDNSlocal void InitDNSPNState(DNSQuestion *const question)
11876{
11877 question->dnsPushState = DNSPUSH_INIT;
11878}
11879#endif // DNS_PUSH_ENABLED
11880
11881// InitDNSSECProxyState() is called by mDNS_StartQuery_internal() to initialize
11882// DNSSEC & DNS Proxy fields of the DNS Question.
11883mDNSlocal void InitDNSSECProxyState(mDNS *const m, DNSQuestion *const question)
11884{
11885 (void) m;
11886
11887 // DNS server selection affects DNSSEC. Turn off validation if req_DO is not set
11888 // or the request is going over cellular interface.
11889 //
11890 // Note: This needs to be done here before we call FindDuplicateQuestion as it looks
11891 // at ValidationRequired setting also.
11892 if (question->qDNSServer)
11893 {
11894 if (question->qDNSServer->cellIntf)
11895 {
11896 debugf("InitDNSSECProxyState: Turning off validation for %##s (%s); going over cell", question->qname.c, DNSTypeName(question->qtype));
11897 question->ValidationRequired = mDNSfalse;
11898 }
11899 if (DNSSECOptionalQuestion(question) && !(question->qDNSServer->req_DO))
11900 {
11901 LogInfo("InitDNSSECProxyState: Turning off validation for %##s (%s); req_DO false",
11902 question->qname.c, DNSTypeName(question->qtype));
11903 question->ValidationRequired = DNSSEC_VALIDATION_NONE;
11904 }
11905 }
11906 question->ValidationState = (question->ValidationRequired ? DNSSECValRequired : DNSSECValNotRequired);
11907 question->ValidationStatus = 0;
11908 question->responseFlags = zeroID;
11909}
11910
11911// Once the question is completely initialized including the duplicate logic, this function
11912// is called to finalize the unicast question which requires flushing the cache if needed,
11913// activating the query etc.
11914mDNSlocal void FinalizeUnicastQuestion(mDNS *const m, DNSQuestion *question, mDNSBool purge)
11915{
11916 // Ensure DNS related info of duplicate question is same as the orig question
11917 if (question->DuplicateOf)
11918 {
11919 question->validDNSServers = question->DuplicateOf->validDNSServers;
11920 // If current(dup) question has DNS Server assigned but the original question has no DNS Server assigned to it,
11921 // then we log a line as it could indicate an issue
11922 if (question->DuplicateOf->qDNSServer == mDNSNULL)
11923 {
11924 if (question->qDNSServer)
11925 LogInfo("FinalizeUnicastQuestion: Current(dup) question %p has DNSServer(%#a:%d) but original question(%p) has no DNS Server! %##s (%s)",
11926 question, question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL,
11927 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort),
11928 question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype));
11929 }
11930 question->qDNSServer = question->DuplicateOf->qDNSServer;
11931 LogInfo("FinalizeUnicastQuestion: Duplicate question %p (%p) %##s (%s), DNS Server %#a:%d",
11932 question, question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype),
11933 question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL,
11934 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort));
11935 }
11936
11937 ActivateUnicastQuery(m, question, mDNSfalse);
11938
11939 // If purge was set above, flush the cache. Need to do this after we set the
11940 // DNS server on the question
11941 if (purge)
11942 {
11943 question->DelayAnswering = 0;
11944 mDNS_PurgeForQuestion(m, question);
11945 }
11946 else if (!question->DuplicateOf && DNSSECQuestion(question))
11947 {
11948 // For DNSSEC questions, we need to have the RRSIGs also for verification.
11949 CheckForDNSSECRecords(m, question);
11950 }
11951 if (question->LongLived)
11952 {
11953 // Unlike other initializations, InitLLQNATState should be done after
11954 // we determine that it is a unicast question. LongLived is set for
11955 // both multicast and unicast browse questions but we should initialize
11956 // the LLQ NAT state only for unicast. Otherwise we will unnecessarily
11957 // start the NAT traversal that is not needed.
11958 InitLLQNATState(m);
11959#if APPLE_OSX_mDNSResponder
11960 UpdateAutoTunnelDomainStatuses(m);
11961#endif
11962 }
11963}
11964
11965mDNSexport mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question)
11966{
11967 DNSQuestion **q;
11968 mStatus vStatus;
11969 mDNSBool purge;
11970
11971 // First check for cache space (can't do queries if there is no cache space allocated)
11972 if (m->rrcache_size == 0)
11973 return(mStatus_NoCache);
11974
11975 vStatus = ValidateParameters(m, question);
11976 if (vStatus)
11977 return(vStatus);
11978
11979#ifdef USE_LIBIDN
11980 // If the TLD includes high-ascii bytes, assume it will need to be converted to Punycode.
11981 // (In the future the root name servers may answer UTF-8 queries directly, but for now they do not.)
11982 if (IsHighASCIILabel(LastLabel(&question->qname)))
11983 {
11984 domainname newname;
11985 if (PerformNextPunycodeConversion(question, &newname))
11986 AssignDomainName(&question->qname, &newname);
11987 }
11988#endif // USE_LIBIDN
11989
11990 question->TargetQID =
11991#ifndef UNICAST_DISABLED
11992 (question->Target.type || Question_uDNS(question)) ? mDNS_NewMessageID(m) :
11993#endif // UNICAST_DISABLED
11994 zeroID;
11995 debugf("mDNS_StartQuery_internal: %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
11996
11997 // Note: It important that new questions are appended at the *end* of the list, not prepended at the start
11998 q = &m->Questions;
11999 if (LocalOnlyOrP2PInterface(question->InterfaceID))
12000 q = &m->LocalOnlyQuestions;
12001 while (*q && *q != question)
12002 q=&(*q)->next;
12003
12004 if (*q)
12005 {
12006 LogMsg("mDNS_StartQuery_internal: Error! Tried to add a question %##s (%s) %p that's already in the active list",
12007 question->qname.c, DNSTypeName(question->qtype), question);
12008 return(mStatus_AlreadyRegistered);
12009 }
12010 *q = question;
12011
12012 // Intialize the question. The only ordering constraint we have today is that
12013 // InitDNSSECProxyState should be called after the DNS server is selected (in
12014 // InitCommonState -> InitDNSConfig) as DNS server selection affects DNSSEC
12015 // validation.
12016
12017 purge = InitCommonState(m, question);
12018 InitWABState(question);
12019 InitLLQState(question);
12020#ifdef DNS_PUSH_ENABLED
12021 InitDNSPNState(question);
12022#endif // DNS_PUSH_ENABLED
12023 InitDNSSECProxyState(m, question);
12024
12025 // FindDuplicateQuestion should be called last after all the intialization
12026 // as the duplicate logic could be potentially based on any field in the
12027 // question.
12028 question->DuplicateOf = FindDuplicateQuestion(m, question);
12029 if (question->DuplicateOf)
12030 question->AuthInfo = question->DuplicateOf->AuthInfo;
12031
12032 if (LocalOnlyOrP2PInterface(question->InterfaceID))
12033 {
12034 if (!m->NewLocalOnlyQuestions)
12035 m->NewLocalOnlyQuestions = question;
12036 }
12037 else
12038 {
12039 if (!m->NewQuestions)
12040 m->NewQuestions = question;
12041
12042 // If the question's id is non-zero, then it's Wide Area
12043 // MUST NOT do this Wide Area setup until near the end of
12044 // mDNS_StartQuery_internal -- this code may itself issue queries (e.g. SOA,
12045 // NS, etc.) and if we haven't finished setting up our own question and setting
12046 // m->NewQuestions if necessary then we could end up recursively re-entering
12047 // this routine with the question list data structures in an inconsistent state.
12048 if (!mDNSOpaque16IsZero(question->TargetQID))
12049 {
12050 FinalizeUnicastQuestion(m, question, purge);
12051 }
12052 else
12053 {
12054#if BONJOUR_ON_DEMAND
12055 m->NumAllInterfaceQuestions++;
12056 LogInfo("mDNS_StartQuery_internal: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %##s (%s)",
12057 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, question->qname.c, DNSTypeName(question->qtype));
12058 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1)
12059 {
12060 m->NextBonjourDisableTime = 0;
12061 if (m->BonjourEnabled == 0)
12062 {
12063 // Enable Bonjour immediately by scheduling network changed processing where
12064 // we will join the multicast group on each active interface.
12065 m->BonjourEnabled = 1;
12066 m->NetworkChanged = m->timenow;
12067 }
12068 }
12069#endif // BONJOUR_ON_DEMAND
12070 if (purge)
12071 {
12072 LogInfo("mDNS_StartQuery_internal: Purging for %##s", question->qname.c);
12073 mDNS_PurgeForQuestion(m, question);
12074 }
12075 }
12076 }
12077
12078 return(mStatus_NoError);
12079}
12080
12081// CancelGetZoneData is an internal routine (i.e. must be called with the lock already held)
12082mDNSexport void CancelGetZoneData(mDNS *const m, ZoneData *nta)
12083{
12084 debugf("CancelGetZoneData %##s (%s)", nta->question.qname.c, DNSTypeName(nta->question.qtype));
12085 // This function may be called anytime to free the zone information.The question may or may not have stopped.
12086 // If it was already stopped, mDNS_StopQuery_internal would have set q->ThisQInterval to -1 and should not
12087 // call it again
12088 if (nta->question.ThisQInterval != -1)
12089 {
12090 mDNS_StopQuery_internal(m, &nta->question);
12091 if (nta->question.ThisQInterval != -1)
12092 LogMsg("CancelGetZoneData: Question %##s (%s) ThisQInterval %d not -1", nta->question.qname.c, DNSTypeName(nta->question.qtype), nta->question.ThisQInterval);
12093 }
12094 mDNSPlatformMemFree(nta);
12095}
12096
12097mDNSexport mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question)
12098{
12099 CacheGroup *cg = CacheGroupForName(m, question->qnamehash, &question->qname);
12100 CacheRecord *rr;
12101 DNSQuestion **qp = &m->Questions;
12102
12103 //LogInfo("mDNS_StopQuery_internal %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
12104
12105 if (LocalOnlyOrP2PInterface(question->InterfaceID))
12106 qp = &m->LocalOnlyQuestions;
12107 while (*qp && *qp != question) qp=&(*qp)->next;
12108 if (*qp) *qp = (*qp)->next;
12109 else
12110 {
12111#if !ForceAlerts
12112 if (question->ThisQInterval >= 0) // Only log error message if the query was supposed to be active
12113#endif
12114 LogFatalError("mDNS_StopQuery_internal: Question %##s (%s) not found in active list", question->qname.c, DNSTypeName(question->qtype));
12115 return(mStatus_BadReferenceErr);
12116 }
12117
12118#if BONJOUR_ON_DEMAND
12119 if (!LocalOnlyOrP2PInterface(question->InterfaceID) && mDNSOpaque16IsZero(question->TargetQID))
12120 {
12121 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1)
12122 m->NextBonjourDisableTime = NonZeroTime(m->timenow + (BONJOUR_DISABLE_DELAY * mDNSPlatformOneSecond));
12123 m->NumAllInterfaceQuestions--;
12124 LogInfo("mDNS_StopQuery_internal: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %##s (%s)",
12125 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, question->qname.c, DNSTypeName(question->qtype));
12126 }
12127#endif // BONJOUR_ON_DEMAND
12128
12129#if AWD_METRICS
12130 if (Question_uDNS(question) && !question->metrics.answered && (question->metrics.querySendCount > 0))
12131 {
12132 const domainname * queryName;
12133 mDNSBool isForCell;
12134 mDNSu32 durationMs;
12135
12136 queryName = question->metrics.originalQName ? question->metrics.originalQName : &question->qname;
12137 isForCell = (question->qDNSServer && question->qDNSServer->cellIntf);
12138 durationMs = ((m->timenow - question->metrics.firstQueryTime) * 1000) / mDNSPlatformOneSecond;
12139 MetricsUpdateDNSQueryStats(queryName, question->qtype, mDNSNULL, question->metrics.querySendCount, durationMs, isForCell);
12140 }
12141#endif
12142 // Take care to cut question from list *before* calling UpdateQuestionDuplicates
12143 UpdateQuestionDuplicates(m, question);
12144 // But don't trash ThisQInterval until afterwards.
12145 question->ThisQInterval = -1;
12146
12147 // If there are any cache records referencing this as their active question, then see if there is any
12148 // other question that is also referencing them, else their CRActiveQuestion needs to get set to NULL.
12149 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
12150 {
12151 if (rr->CRActiveQuestion == question)
12152 {
12153 DNSQuestion *q;
12154 DNSQuestion *replacement = mDNSNULL;
12155 // If we find an active question that is answered by this cached record, use it as the cache record's
12156 // CRActiveQuestion replacement. If there are no such questions, but there's at least one unsuppressed inactive
12157 // question that is answered by this cache record, then use an inactive one to not forgo generating RMV events
12158 // via CacheRecordRmv() when the cache record expires.
12159 for (q = m->Questions; q && (q != m->NewQuestions); q = q->next)
12160 {
12161 if (!q->DuplicateOf && !QuerySuppressed(q) && ResourceRecordAnswersQuestion(&rr->resrec, q))
12162 {
12163 if (q->ThisQInterval > 0)
12164 {
12165 replacement = q;
12166 break;
12167 }
12168 else if (!replacement)
12169 {
12170 replacement = q;
12171 }
12172 }
12173 }
12174 if (replacement)
12175 debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s, Original question CurrentAnswers %d, new question "
12176 "CurrentAnswers %d, SuppressQuery %d", replacement, CRDisplayString(m,rr), question->CurrentAnswers, replacement->CurrentAnswers, replacement->SuppressQuery);
12177 rr->CRActiveQuestion = replacement; // Question used to be active; new value may or may not be null
12178 if (!replacement) m->rrcache_active--; // If no longer active, decrement rrcache_active count
12179 }
12180 }
12181
12182 // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv() is about to look at,
12183 // bump its pointer forward one question.
12184 if (m->CurrentQuestion == question)
12185 {
12186 debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)",
12187 question->qname.c, DNSTypeName(question->qtype));
12188 m->CurrentQuestion = question->next;
12189 }
12190
12191 if (m->NewQuestions == question)
12192 {
12193 debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)",
12194 question->qname.c, DNSTypeName(question->qtype));
12195 m->NewQuestions = question->next;
12196 }
12197
12198 if (m->NewLocalOnlyQuestions == question) m->NewLocalOnlyQuestions = question->next;
12199
12200 if (m->RestartQuestion == question)
12201 {
12202 LogMsg("mDNS_StopQuery_internal: Just deleted the current restart question: %##s (%s)",
12203 question->qname.c, DNSTypeName(question->qtype));
12204 m->RestartQuestion = question->next;
12205 }
12206
12207 if (m->ValidationQuestion == question)
12208 {
12209 LogInfo("mDNS_StopQuery_internal: Just deleted the current Validation question: %##s (%s)",
12210 question->qname.c, DNSTypeName(question->qtype));
12211 m->ValidationQuestion = question->next;
12212 }
12213
12214 // Take care not to trash question->next until *after* we've updated m->CurrentQuestion and m->NewQuestions
12215 question->next = mDNSNULL;
12216
12217 // LogMsg("mDNS_StopQuery_internal: Question %##s (%s) removed", question->qname.c, DNSTypeName(question->qtype));
12218
12219 // And finally, cancel any associated GetZoneData operation that's still running.
12220 // Must not do this until last, because there's a good chance the GetZoneData question is the next in the list,
12221 // so if we delete it earlier in this routine, we could find that our "question->next" pointer above is already
12222 // invalid before we even use it. By making sure that we update m->CurrentQuestion and m->NewQuestions if necessary
12223 // *first*, then they're all ready to be updated a second time if necessary when we cancel our GetZoneData query.
12224 if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; }
12225 if (question->LocalSocket) { mDNSPlatformUDPClose(question->LocalSocket); question->LocalSocket = mDNSNULL; }
12226 if (!mDNSOpaque16IsZero(question->TargetQID) && question->LongLived)
12227 {
12228 // Scan our list to see if any more wide-area LLQs remain. If not, stop our NAT Traversal.
12229 DNSQuestion *q;
12230 for (q = m->Questions; q; q=q->next)
12231 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) break;
12232 if (!q)
12233 {
12234 if (!m->LLQNAT.clientCallback) // Should never happen, but just in case...
12235 {
12236 LogMsg("mDNS_StopQuery ERROR LLQNAT.clientCallback NULL");
12237 }
12238 else
12239 {
12240 LogInfo("Stopping LLQNAT");
12241 mDNS_StopNATOperation_internal(m, &m->LLQNAT);
12242 m->LLQNAT.clientCallback = mDNSNULL; // Means LLQ NAT Traversal not running
12243 }
12244 }
12245
12246 // If necessary, tell server it can delete this LLQ state
12247 if (question->state == LLQ_Established)
12248 {
12249 question->ReqLease = 0;
12250 sendLLQRefresh(m, question);
12251 // If we need need to make a TCP connection to cancel the LLQ, that's going to take a little while.
12252 // We clear the tcp->question backpointer so that when the TCP connection completes, it doesn't
12253 // crash trying to access our cancelled question, but we don't cancel the TCP operation itself --
12254 // we let that run out its natural course and complete asynchronously.
12255 if (question->tcp)
12256 {
12257 question->tcp->question = mDNSNULL;
12258 question->tcp = mDNSNULL;
12259 }
12260 }
12261#ifdef DNS_PUSH_ENABLED
12262 else if (question->dnsPushState == DNSPUSH_ESTABLISHED)
12263 {
12264 if (question->tcp)
12265 {
12266 UnSubscribeToDNSPushNotificationServer(m, q);
12267 question->tcp->question = mDNSNULL;
12268 question->tcp = mDNSNULL;
12269 }
12270 }
12271#endif // DNS_PUSH_ENABLED
12272#if APPLE_OSX_mDNSResponder
12273 UpdateAutoTunnelDomainStatuses(m);
12274#endif
12275 }
12276 // wait until we send the refresh above which needs the nta
12277 if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; }
12278
12279 if (question->ValidationRequired && question->DNSSECAuthInfo)
12280 {
12281 LogInfo("mDNS_StopQuery_internal: freeing DNSSECAuthInfo %##s", question->qname.c);
12282 question->DAIFreeCallback(m, question->DNSSECAuthInfo);
12283 question->DNSSECAuthInfo = mDNSNULL;
12284 }
12285 if (question->AnonInfo)
12286 {
12287 FreeAnonInfo(question->AnonInfo);
12288 question->AnonInfo = mDNSNULL;
12289 }
12290#if AWD_METRICS
12291 if (question->metrics.originalQName)
12292 {
12293 mDNSPlatformMemFree(question->metrics.originalQName);
12294 question->metrics.originalQName = mDNSNULL;
12295 }
12296#endif
12297
12298#if USE_DNS64
12299 DNS64ResetState(question);
12300#endif
12301
12302 return(mStatus_NoError);
12303}
12304
12305mDNSexport mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question)
12306{
12307 mStatus status;
12308 mDNS_Lock(m);
12309 status = mDNS_StartQuery_internal(m, question);
12310 mDNS_Unlock(m);
12311 return(status);
12312}
12313
12314mDNSexport mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question)
12315{
12316 mStatus status;
12317 mDNS_Lock(m);
12318 status = mDNS_StopQuery_internal(m, question);
12319 mDNS_Unlock(m);
12320 return(status);
12321}
12322
12323// Note that mDNS_StopQueryWithRemoves() does not currently implement the full generality of the other APIs
12324// Specifically, question callbacks invoked as a result of this call cannot themselves make API calls.
12325// We invoke the callback without using mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback
12326// specifically to catch and report if the client callback does try to make API calls
12327mDNSexport mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question)
12328{
12329 mStatus status;
12330 DNSQuestion *qq;
12331 mDNS_Lock(m);
12332
12333 // Check if question is new -- don't want to give remove events for a question we haven't even answered yet
12334 for (qq = m->NewQuestions; qq; qq=qq->next) if (qq == question) break;
12335
12336 status = mDNS_StopQuery_internal(m, question);
12337 if (status == mStatus_NoError && !qq)
12338 {
12339 const CacheRecord *rr;
12340 CacheGroup *const cg = CacheGroupForName(m, question->qnamehash, &question->qname);
12341 LogInfo("Generating terminal removes for %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
12342 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
12343 if (rr->resrec.RecordType != kDNSRecordTypePacketNegative && SameNameRecordAnswersQuestion(&rr->resrec, question))
12344 {
12345 // Don't use mDNS_DropLockBeforeCallback() here, since we don't allow API calls
12346 if (question->QuestionCallback)
12347 question->QuestionCallback(m, question, &rr->resrec, mDNSfalse);
12348 }
12349 }
12350 mDNS_Unlock(m);
12351 return(status);
12352}
12353
12354mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const cr)
12355{
12356 mStatus status;
12357 mDNS_Lock(m);
12358 status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
12359 if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0);
12360 mDNS_Unlock(m);
12361 return(status);
12362}
12363
12364mDNSexport mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr)
12365{
12366 mStatus status = mStatus_BadReferenceErr;
12367 CacheRecord *cr;
12368 mDNS_Lock(m);
12369 cr = FindIdenticalRecordInCache(m, rr);
12370 debugf("mDNS_ReconfirmByValue: %p %s", cr, RRDisplayString(m, rr));
12371 if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
12372 if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0);
12373 mDNS_Unlock(m);
12374 return(status);
12375}
12376
12377mDNSlocal mStatus mDNS_StartBrowse_internal(mDNS *const m, DNSQuestion *const question,
12378 const domainname *const srv, const domainname *const domain,
12379 const mDNSu8 *anondata, const mDNSInterfaceID InterfaceID, mDNSu32 flags,
12380 mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass,
12381 mDNSQuestionCallback *Callback, void *Context)
12382{
12383 question->InterfaceID = InterfaceID;
12384 question->flags = flags;
12385 question->Target = zeroAddr;
12386 question->qtype = kDNSType_PTR;
12387 question->qclass = kDNSClass_IN;
12388 question->LongLived = mDNStrue;
12389 question->ExpectUnique = mDNSfalse;
12390 question->ForceMCast = ForceMCast;
12391 question->ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
12392 question->SuppressUnusable = mDNSfalse;
12393 question->SearchListIndex = 0;
12394 question->AppendSearchDomains = 0;
12395 question->RetryWithSearchDomains = mDNSfalse;
12396 question->TimeoutQuestion = 0;
12397 question->WakeOnResolve = 0;
12398 question->UseBackgroundTrafficClass = useBackgroundTrafficClass;
12399 question->ValidationRequired = 0;
12400 question->ValidatingResponse = 0;
12401 question->ProxyQuestion = 0;
12402 question->qnameOrig = mDNSNULL;
12403 question->AnonInfo = mDNSNULL;
12404 question->QuestionCallback = Callback;
12405 question->QuestionContext = Context;
12406
12407 if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain))
12408 return(mStatus_BadParamErr);
12409
12410 if (anondata)
12411 {
12412 question->AnonInfo = AllocateAnonInfo(&question->qname, anondata, mDNSPlatformStrLen(anondata), mDNSNULL);
12413 if (!question->AnonInfo)
12414 return(mStatus_BadParamErr);
12415 }
12416
12417 return(mDNS_StartQuery_internal(m, question));
12418}
12419
12420mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,
12421 const domainname *const srv, const domainname *const domain,
12422 const mDNSu8 *anondata, const mDNSInterfaceID InterfaceID, mDNSu32 flags,
12423 mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass,
12424 mDNSQuestionCallback *Callback, void *Context)
12425{
12426 mStatus status;
12427 mDNS_Lock(m);
12428 status = mDNS_StartBrowse_internal(m, question, srv, domain, anondata, InterfaceID, flags, ForceMCast, useBackgroundTrafficClass, Callback, Context);
12429 mDNS_Unlock(m);
12430 return(status);
12431}
12432
12433
12434mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom,
12435 const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
12436{
12437 question->InterfaceID = InterfaceID;
12438 question->flags = 0;
12439 question->Target = zeroAddr;
12440 question->qtype = kDNSType_PTR;
12441 question->qclass = kDNSClass_IN;
12442 question->LongLived = mDNSfalse;
12443 question->ExpectUnique = mDNSfalse;
12444 question->ForceMCast = mDNSfalse;
12445 question->ReturnIntermed = mDNSfalse;
12446 question->SuppressUnusable = mDNSfalse;
12447 question->SearchListIndex = 0;
12448 question->AppendSearchDomains = 0;
12449 question->RetryWithSearchDomains = mDNSfalse;
12450 question->TimeoutQuestion = 0;
12451 question->WakeOnResolve = 0;
12452 question->UseBackgroundTrafficClass = mDNSfalse;
12453 question->ValidationRequired = 0;
12454 question->ValidatingResponse = 0;
12455 question->ProxyQuestion = 0;
12456 question->qnameOrig = mDNSNULL;
12457 question->AnonInfo = mDNSNULL;
12458 question->pid = mDNSPlatformGetPID();
12459 question->euid = 0;
12460 question->QuestionCallback = Callback;
12461 question->QuestionContext = Context;
12462 if (DomainType > mDNS_DomainTypeMax) return(mStatus_BadParamErr);
12463 if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
12464 if (!dom) dom = &localdomain;
12465 if (!AppendDomainName(&question->qname, dom)) return(mStatus_BadParamErr);
12466 return(mDNS_StartQuery(m, question));
12467}
12468
12469// ***************************************************************************
12470#if COMPILER_LIKES_PRAGMA_MARK
12471#pragma mark -
12472#pragma mark - Responder Functions
12473#endif
12474
12475mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr)
12476{
12477 mStatus status;
12478 mDNS_Lock(m);
12479 status = mDNS_Register_internal(m, rr);
12480 mDNS_Unlock(m);
12481 return(status);
12482}
12483
12484mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,
12485 const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback)
12486{
12487 if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata))
12488 {
12489 LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(&rr->resrec, &newrdata->u, m->MsgBuffer));
12490 return(mStatus_Invalid);
12491 }
12492
12493 mDNS_Lock(m);
12494
12495 // If TTL is unspecified, leave TTL unchanged
12496 if (newttl == 0) newttl = rr->resrec.rroriginalttl;
12497
12498 // If we already have an update queued up which has not gone through yet, give the client a chance to free that memory
12499 if (rr->NewRData)
12500 {
12501 RData *n = rr->NewRData;
12502 rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...
12503 if (rr->UpdateCallback)
12504 rr->UpdateCallback(m, rr, n, rr->newrdlength); // ...and let the client free this memory, if necessary
12505 }
12506
12507 rr->NewRData = newrdata;
12508 rr->newrdlength = newrdlength;
12509 rr->UpdateCallback = Callback;
12510
12511#ifndef UNICAST_DISABLED
12512 if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P && !IsLocalDomain(rr->resrec.name))
12513 {
12514 mStatus status = uDNS_UpdateRecord(m, rr);
12515 // The caller frees the memory on error, don't retain stale pointers
12516 if (status != mStatus_NoError) { rr->NewRData = mDNSNULL; rr->newrdlength = 0; }
12517 mDNS_Unlock(m);
12518 return(status);
12519 }
12520#endif
12521
12522 if (RRLocalOnly(rr) || (rr->resrec.rroriginalttl == newttl &&
12523 rr->resrec.rdlength == newrdlength && mDNSPlatformMemSame(rr->resrec.rdata->u.data, newrdata->u.data, newrdlength)))
12524 CompleteRDataUpdate(m, rr);
12525 else
12526 {
12527 rr->AnnounceCount = InitialAnnounceCount;
12528 InitializeLastAPTime(m, rr);
12529 while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr);
12530 if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--;
12531 if (!rr->NextUpdateCredit) rr->NextUpdateCredit = NonZeroTime(m->timenow + kUpdateCreditRefreshInterval);
12532 if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1);
12533 if (rr->UpdateCredits <= 5)
12534 {
12535 mDNSu32 delay = 6 - rr->UpdateCredits; // Delay 1 second, then 2, then 3, etc. up to 6 seconds maximum
12536 if (!rr->UpdateBlocked) rr->UpdateBlocked = NonZeroTime(m->timenow + (mDNSs32)delay * mDNSPlatformOneSecond);
12537 rr->ThisAPInterval *= 4;
12538 rr->LastAPTime = rr->UpdateBlocked - rr->ThisAPInterval;
12539 LogMsg("Excessive update rate for %##s; delaying announcement by %ld second%s",
12540 rr->resrec.name->c, delay, delay > 1 ? "s" : "");
12541 }
12542 rr->resrec.rroriginalttl = newttl;
12543 }
12544
12545 mDNS_Unlock(m);
12546 return(mStatus_NoError);
12547}
12548
12549// Note: mDNS_Deregister calls mDNS_Deregister_internal which can call a user callback, which may change
12550// the record list and/or question list.
12551// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
12552mDNSexport mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr)
12553{
12554 mStatus status;
12555 mDNS_Lock(m);
12556 status = mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
12557 mDNS_Unlock(m);
12558 return(status);
12559}
12560
12561// Circular reference: AdvertiseInterface references mDNS_HostNameCallback, which calls mDNS_SetFQDN, which call AdvertiseInterface
12562mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
12563
12564mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m)
12565{
12566 NetworkInterfaceInfo *intf;
12567 for (intf = m->HostInterfaces; intf; intf = intf->next)
12568 if (intf->Advertise) break;
12569 return(intf);
12570}
12571
12572// The parameter "set" here refers to the set of AuthRecords used to advertise this interface.
12573// (It's a set of records, not a set of interfaces.)
12574mDNSlocal void AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
12575{
12576 char buffer[MAX_REVERSE_MAPPING_NAME];
12577 NetworkInterfaceInfo *primary;
12578 mDNSu8 recordType;
12579
12580 if (m->AutoTargetServices == 0)
12581 {
12582 LogInfo("AdvertiseInterface: Returning due to AutoTargetServices zero for %s", set->ifname);
12583 return;
12584 }
12585
12586 primary = FindFirstAdvertisedInterface(m);
12587 if (!primary) primary = set; // If no existing advertised interface, this new NetworkInterfaceInfo becomes our new primary
12588 // We should never have primary be NULL, because even if there is
12589 // no other interface yet, we should always find ourself in the list.
12590
12591 // If interface is marked as a direct link, we can assume the address record is unique
12592 // and does not need to go through the probe phase of the probe/announce packet sequence.
12593 recordType = (set->DirectLink ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique);
12594
12595 if (set->DirectLink)
12596 LogInfo("AdvertiseInterface: Marking address record as kDNSRecordTypeKnownUnique for %s", set->ifname);
12597
12598 // Send dynamic update for non-linklocal IPv4 Addresses
12599 mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kHostNameTTL, recordType, AuthRecordAny, mDNS_HostNameCallback, set);
12600 mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
12601 mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kHostNameTTL, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
12602
12603#if ANSWER_REMOTE_HOSTNAME_QUERIES
12604 set->RR_A.AllowRemoteQuery = mDNStrue;
12605 set->RR_PTR.AllowRemoteQuery = mDNStrue;
12606 set->RR_HINFO.AllowRemoteQuery = mDNStrue;
12607#endif
12608 // 1. Set up Address record to map from host name ("foo.local.") to IP address
12609 // 2. Set up reverse-lookup PTR record to map from our address back to our host name
12610 AssignDomainName(&set->RR_A.namestorage, &m->MulticastHostname);
12611 if (set->ip.type == mDNSAddrType_IPv4)
12612 {
12613 set->RR_A.resrec.rrtype = kDNSType_A;
12614 set->RR_A.resrec.rdata->u.ipv4 = set->ip.ip.v4;
12615 // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code
12616 mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.",
12617 set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]);
12618 }
12619 else if (set->ip.type == mDNSAddrType_IPv6)
12620 {
12621 int i;
12622 set->RR_A.resrec.rrtype = kDNSType_AAAA;
12623 set->RR_A.resrec.rdata->u.ipv6 = set->ip.ip.v6;
12624 for (i = 0; i < 16; i++)
12625 {
12626 static const char hexValues[] = "0123456789ABCDEF";
12627 buffer[i * 4 ] = hexValues[set->ip.ip.v6.b[15 - i] & 0x0F];
12628 buffer[i * 4 + 1] = '.';
12629 buffer[i * 4 + 2] = hexValues[set->ip.ip.v6.b[15 - i] >> 4];
12630 buffer[i * 4 + 3] = '.';
12631 }
12632 mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa.");
12633 }
12634
12635 MakeDomainNameFromDNSNameString(&set->RR_PTR.namestorage, buffer);
12636 set->RR_PTR.AutoTarget = Target_AutoHost; // Tell mDNS that the target of this PTR is to be kept in sync with our host name
12637 set->RR_PTR.ForceMCast = mDNStrue; // This PTR points to our dot-local name, so don't ever try to write it into a uDNS server
12638
12639 set->RR_A.RRSet = &primary->RR_A; // May refer to self
12640
12641 mDNS_Register_internal(m, &set->RR_A);
12642 mDNS_Register_internal(m, &set->RR_PTR);
12643
12644#if APPLE_OSX_mDNSResponder
12645 // must be after the mDNS_Register_internal() calls so that records have complete rdata fields, etc
12646 D2D_start_advertising_interface(set);
12647#endif // APPLE_OSX_mDNSResponder
12648
12649 if (!NO_HINFO && m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254)
12650 {
12651 mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data;
12652 AssignDomainName(&set->RR_HINFO.namestorage, &m->MulticastHostname);
12653 set->RR_HINFO.DependentOn = &set->RR_A;
12654 mDNSPlatformMemCopy(p, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]);
12655 p += 1 + (int)p[0];
12656 mDNSPlatformMemCopy(p, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]);
12657 mDNS_Register_internal(m, &set->RR_HINFO);
12658 }
12659 else
12660 {
12661 debugf("Not creating HINFO record: platform support layer provided no information");
12662 set->RR_HINFO.resrec.RecordType = kDNSRecordTypeUnregistered;
12663 }
12664}
12665
12666mDNSlocal void DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
12667{
12668 if (m->AutoTargetServices == 0)
12669 {
12670 LogInfo("DeadvertiseInterface: Returning due to AutoTargetServices zero for %s", set->ifname);
12671 return;
12672 }
12673
12674#if APPLE_OSX_mDNSResponder
12675 D2D_stop_advertising_interface(set);
12676#endif // APPLE_OSX_mDNSResponder
12677
12678 // Unregister these records.
12679 // When doing the mDNS_Exit processing, we first call DeadvertiseInterface for each interface, so by the time the platform
12680 // support layer gets to call mDNS_DeregisterInterface, the address and PTR records have already been deregistered for it.
12681 // Also, in the event of a name conflict, one or more of our records will have been forcibly deregistered.
12682 // To avoid unnecessary and misleading warning messages, we check the RecordType before calling mDNS_Deregister_internal().
12683 if (set->RR_A .resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_A, mDNS_Dereg_normal);
12684 if (set->RR_PTR .resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_PTR, mDNS_Dereg_normal);
12685 if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal);
12686}
12687
12688mDNSlocal void AdvertiseAllInterfaceRecords(mDNS *const m)
12689{
12690 NetworkInterfaceInfo *intf;
12691 for (intf = m->HostInterfaces; intf; intf = intf->next)
12692 {
12693 if (intf->Advertise)
12694 {
12695 LogInfo("AdvertiseInterface: Advertising for ifname %s", intf->ifname);
12696 AdvertiseInterface(m, intf);
12697 }
12698 }
12699}
12700
12701mDNSlocal void DeadvertiseAllInterfaceRecords(mDNS *const m)
12702{
12703 NetworkInterfaceInfo *intf;
12704 for (intf = m->HostInterfaces; intf; intf = intf->next)
12705 {
12706 if (intf->Advertise)
12707 {
12708 LogInfo("DeadvertiseInterface: Deadvertising for ifname %s", intf->ifname);
12709 DeadvertiseInterface(m, intf);
12710 }
12711 }
12712}
12713
12714// Change target host name for record.
12715mDNSlocal void UpdateTargetHostName(mDNS *const m, AuthRecord *const rr)
12716{
12717#if APPLE_OSX_mDNSResponder
12718 // If this record was also registered with any D2D plugins, stop advertising
12719 // the version with the old host name.
12720 D2D_stop_advertising_record(rr);
12721#endif
12722
12723 SetTargetToHostName(m, rr);
12724
12725#if APPLE_OSX_mDNSResponder
12726 // Advertise the record with the updated host name with the D2D plugins if appropriate.
12727 D2D_start_advertising_record(rr);
12728#endif
12729}
12730
12731mDNSexport void mDNS_SetFQDN(mDNS *const m)
12732{
12733 domainname newmname;
12734 AuthRecord *rr;
12735 newmname.c[0] = 0;
12736
12737 if (!AppendDomainLabel(&newmname, &m->hostlabel)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
12738 if (!AppendLiteralLabelString(&newmname, "local")) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
12739
12740 mDNS_Lock(m);
12741
12742 if (SameDomainNameCS(&m->MulticastHostname, &newmname)) debugf("mDNS_SetFQDN - hostname unchanged");
12743 else
12744 {
12745 AssignDomainName(&m->MulticastHostname, &newmname);
12746 DeadvertiseAllInterfaceRecords(m);
12747 AdvertiseAllInterfaceRecords(m);
12748 }
12749
12750 // 3. Make sure that any AutoTarget SRV records (and the like) get updated
12751 for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->AutoTarget) UpdateTargetHostName(m, rr);
12752 for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->AutoTarget) UpdateTargetHostName(m, rr);
12753
12754 mDNS_Unlock(m);
12755}
12756
12757mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
12758{
12759 (void)rr; // Unused parameter
12760
12761 #if MDNS_DEBUGMSGS
12762 {
12763 char *msg = "Unknown result";
12764 if (result == mStatus_NoError) msg = "Name registered";
12765 else if (result == mStatus_NameConflict) msg = "Name conflict";
12766 debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result);
12767 }
12768 #endif
12769
12770 if (result == mStatus_NoError)
12771 {
12772 // Notify the client that the host name is successfully registered
12773 if (m->MainCallback)
12774 m->MainCallback(m, mStatus_NoError);
12775 }
12776 else if (result == mStatus_NameConflict)
12777 {
12778 domainlabel oldlabel = m->hostlabel;
12779
12780 // 1. First give the client callback a chance to pick a new name
12781 if (m->MainCallback)
12782 m->MainCallback(m, mStatus_NameConflict);
12783
12784 // 2. If the client callback didn't do it, add (or increment) an index ourselves
12785 // This needs to be case-INSENSITIVE compare, because we need to know that the name has been changed so as to
12786 // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again.
12787 if (SameDomainLabel(m->hostlabel.c, oldlabel.c))
12788 IncrementLabelSuffix(&m->hostlabel, mDNSfalse);
12789
12790 // 3. Generate the FQDNs from the hostlabel,
12791 // and make sure all SRV records, etc., are updated to reference our new hostname
12792 mDNS_SetFQDN(m);
12793 LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead", oldlabel.c, m->hostlabel.c);
12794 }
12795 else if (result == mStatus_MemFree)
12796 {
12797 // .local hostnames do not require goodbyes - we ignore the MemFree (which is sent directly by
12798 // mDNS_Deregister_internal), and allow the caller to deallocate immediately following mDNS_DeadvertiseInterface
12799 debugf("mDNS_HostNameCallback: MemFree (ignored)");
12800 }
12801 else
12802 LogMsg("mDNS_HostNameCallback: Unknown error %d for registration of record %s", result, rr->resrec.name->c);
12803}
12804
12805mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active)
12806{
12807 NetworkInterfaceInfo *intf;
12808 active->IPv4Available = mDNSfalse;
12809 active->IPv6Available = mDNSfalse;
12810 for (intf = m->HostInterfaces; intf; intf = intf->next)
12811 if (intf->InterfaceID == active->InterfaceID)
12812 {
12813 if (intf->ip.type == mDNSAddrType_IPv4 && intf->McastTxRx) active->IPv4Available = mDNStrue;
12814 if (intf->ip.type == mDNSAddrType_IPv6 && intf->McastTxRx) active->IPv6Available = mDNStrue;
12815 }
12816}
12817
12818mDNSlocal void RestartRecordGetZoneData(mDNS * const m)
12819{
12820 AuthRecord *rr;
12821 LogInfo("RestartRecordGetZoneData: ResourceRecords");
12822 for (rr = m->ResourceRecords; rr; rr=rr->next)
12823 if (AuthRecord_uDNS(rr) && rr->state != regState_NoTarget)
12824 {
12825 debugf("RestartRecordGetZoneData: StartGetZoneData for %##s", rr->resrec.name->c);
12826 // Zero out the updateid so that if we have a pending response from the server, it won't
12827 // be accepted as a valid response. If we accept the response, we might free the new "nta"
12828 if (rr->nta) { rr->updateid = zeroID; CancelGetZoneData(m, rr->nta); }
12829 rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationGotZoneData, rr);
12830 }
12831}
12832
12833mDNSlocal void InitializeNetWakeState(mDNS *const m, NetworkInterfaceInfo *set)
12834{
12835 int i;
12836 // We initialize ThisQInterval to -1 indicating that the question has not been started
12837 // yet. If the question (browse) is started later during interface registration, it will
12838 // be stopped during interface deregistration. We can't sanity check to see if the
12839 // question has been stopped or not before initializing it to -1 because we need to
12840 // initialize it to -1 the very first time.
12841
12842 set->NetWakeBrowse.ThisQInterval = -1;
12843 for (i=0; i<3; i++)
12844 {
12845 set->NetWakeResolve[i].ThisQInterval = -1;
12846 set->SPSAddr[i].type = mDNSAddrType_None;
12847 }
12848 set->NextSPSAttempt = -1;
12849 set->NextSPSAttemptTime = m->timenow;
12850}
12851
12852mDNSexport void mDNS_ActivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set)
12853{
12854 NetworkInterfaceInfo *p = m->HostInterfaces;
12855 while (p && p != set) p=p->next;
12856 if (!p) { LogMsg("mDNS_ActivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set); return; }
12857
12858 if (set->InterfaceActive)
12859 {
12860 LogSPS("ActivateNetWake for %s (%#a)", set->ifname, &set->ip);
12861 mDNS_StartBrowse_internal(m, &set->NetWakeBrowse, &SleepProxyServiceType, &localdomain, mDNSNULL, set->InterfaceID, 0, mDNSfalse, mDNSfalse, m->SPSBrowseCallback, set);
12862 }
12863}
12864
12865mDNSexport void mDNS_DeactivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set)
12866{
12867 NetworkInterfaceInfo *p = m->HostInterfaces;
12868 while (p && p != set) p=p->next;
12869 if (!p) { LogMsg("mDNS_DeactivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set); return; }
12870
12871 // Note: We start the browse only if the interface is NetWake capable and we use this to
12872 // stop the resolves also. Hence, the resolves should not be started without the browse
12873 // being started i.e, resolves should not happen unless NetWake capable which is
12874 // guaranteed by BeginSleepProcessing.
12875 if (set->NetWakeBrowse.ThisQInterval >= 0)
12876 {
12877 int i;
12878 LogSPS("DeactivateNetWake for %s (%#a)", set->ifname, &set->ip);
12879
12880 // Stop our browse and resolve operations
12881 mDNS_StopQuery_internal(m, &set->NetWakeBrowse);
12882 for (i=0; i<3; i++) if (set->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery_internal(m, &set->NetWakeResolve[i]);
12883
12884 // Make special call to the browse callback to let it know it can to remove all records for this interface
12885 if (m->SPSBrowseCallback)
12886 {
12887 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
12888 m->SPSBrowseCallback(m, &set->NetWakeBrowse, mDNSNULL, mDNSfalse);
12889 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
12890 }
12891
12892 // Reset our variables back to initial state, so we're ready for when NetWake is turned back on
12893 // (includes resetting NetWakeBrowse.ThisQInterval back to -1)
12894 InitializeNetWakeState(m, set);
12895 }
12896}
12897
12898mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set, InterfaceActivationSpeed activationSpeed)
12899{
12900 AuthRecord *rr;
12901 mDNSBool FirstOfType = mDNStrue;
12902 NetworkInterfaceInfo **p = &m->HostInterfaces;
12903
12904 if (!set->InterfaceID)
12905 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID", &set->ip); return(mStatus_Invalid); }
12906
12907 if (!mDNSAddressIsValidNonZero(&set->mask))
12908 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a", &set->ip, &set->mask); return(mStatus_Invalid); }
12909
12910 mDNS_Lock(m);
12911
12912 // Assume this interface will be active now, unless we find a duplicate already in the list
12913 set->InterfaceActive = mDNStrue;
12914 set->IPv4Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx);
12915 set->IPv6Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx);
12916
12917 InitializeNetWakeState(m, set);
12918
12919 // Scan list to see if this InterfaceID is already represented
12920 while (*p)
12921 {
12922 if (*p == set)
12923 {
12924 LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo that's already in the list");
12925 mDNS_Unlock(m);
12926 return(mStatus_AlreadyRegistered);
12927 }
12928
12929 if ((*p)->InterfaceID == set->InterfaceID)
12930 {
12931 // This InterfaceID already represented by a different interface in the list, so mark this instance inactive for now
12932 set->InterfaceActive = mDNSfalse;
12933 if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse;
12934 if (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx) (*p)->IPv4Available = mDNStrue;
12935 if (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx) (*p)->IPv6Available = mDNStrue;
12936 }
12937
12938 p=&(*p)->next;
12939 }
12940
12941 set->next = mDNSNULL;
12942 *p = set;
12943
12944 if (set->Advertise)
12945 AdvertiseInterface(m, set);
12946
12947 LogInfo("mDNS_RegisterInterface: InterfaceID %d %s (%#a) %s",
12948 IID(set->InterfaceID), set->ifname, &set->ip,
12949 set->InterfaceActive ?
12950 "not represented in list; marking active and retriggering queries" :
12951 "already represented in list; marking inactive for now");
12952
12953 if (set->NetWake) mDNS_ActivateNetWake_internal(m, set);
12954
12955 // In early versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
12956 // giving the false impression that there's an active representative of this interface when there really isn't.
12957 // Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records,
12958 // even if we believe that we previously had an active representative of this interface.
12959 if (set->McastTxRx && (FirstOfType || set->InterfaceActive))
12960 {
12961 DNSQuestion *q;
12962 // Normally, after an interface comes up, we pause half a second before beginning probing.
12963 // This is to guard against cases where there's rapid interface changes, where we could be confused by
12964 // seeing packets we ourselves sent just moments ago (perhaps when this interface had a different address)
12965 // which are then echoed back after a short delay by some Ethernet switches and some 802.11 base stations.
12966 // We don't want to do a probe, and then see a stale echo of an announcement we ourselves sent,
12967 // and think it's a conflicting answer to our probe.
12968 // In the case of a flapping interface, we pause for five seconds, and reduce the announcement count to one packet.
12969 mDNSs32 probedelay;
12970 mDNSu8 numannounce;
12971 switch (activationSpeed)
12972 {
12973 case FastActivation:
12974 probedelay = (mDNSs32)0;
12975 numannounce = InitialAnnounceCount;
12976 LogMsg("mDNS_RegisterInterface: Using fast activation for DirectLink interface %s (%#a)", set->ifname, &set->ip);
12977 break;
12978
12979 case SlowActivation:
12980 probedelay = mDNSPlatformOneSecond * 5;
12981 numannounce = (mDNSu8)1;
12982 LogMsg("mDNS_RegisterInterface: Frequent transitions for interface %s (%#a), doing slow activation", set->ifname, &set->ip);
12983 m->mDNSStats.InterfaceUpFlap++;
12984 break;
12985
12986 case NormalActivation:
12987 default:
12988 probedelay = mDNSPlatformOneSecond / 2;
12989 numannounce = InitialAnnounceCount;
12990 break;
12991 }
12992
12993 LogInfo("mDNS_RegisterInterface: %s (%#a) probedelay %d", set->ifname, &set->ip, probedelay);
12994
12995 // No probe or sending suppression on DirectLink type interfaces.
12996 if (activationSpeed == FastActivation)
12997 {
12998 m->SuppressSending = 0;
12999 m->SuppressProbes = 0;
13000 }
13001 else
13002 {
13003 // Use a small amount of randomness:
13004 // In the case of a network administrator turning on an Ethernet hub so that all the
13005 // connected machines establish link at exactly the same time, we don't want them all
13006 // to go and hit the network with identical queries at exactly the same moment.
13007 // We set a random delay of up to InitialQuestionInterval (1/3 second).
13008 // We must *never* set m->SuppressSending to more than that (or set it repeatedly in a way
13009 // that causes mDNSResponder to remain in a prolonged state of SuppressSending, because
13010 // suppressing packet sending for more than about 1/3 second can cause protocol correctness
13011 // to start to break down (e.g. we don't answer probes fast enough, and get name conflicts).
13012 // See <rdar://problem/4073853> mDNS: m->SuppressSending set too enthusiastically
13013 if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
13014
13015 if (m->SuppressProbes == 0 ||
13016 m->SuppressProbes - NonZeroTime(m->timenow + probedelay) < 0)
13017 m->SuppressProbes = NonZeroTime(m->timenow + probedelay);
13018 }
13019
13020 // Include OWNER option in packets for 60 seconds after connecting to the network. Setting
13021 // it here also handles the wake up case as the network link comes UP after waking causing
13022 // us to reconnect to the network. If we do this as part of the wake up code, it is possible
13023 // that the network link comes UP after 60 seconds and we never set the OWNER option
13024 m->AnnounceOwner = NonZeroTime(m->timenow + 60 * mDNSPlatformOneSecond);
13025 LogInfo("mDNS_RegisterInterface: Setting AnnounceOwner");
13026
13027 m->mDNSStats.InterfaceUp++;
13028 for (q = m->Questions; q; q=q->next) // Scan our list of questions
13029 {
13030 if (mDNSOpaque16IsZero(q->TargetQID))
13031 {
13032 if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) // If non-specific Q, or Q on this specific interface,
13033 { // then reactivate this question
13034 // If flapping, delay between first and second queries is nine seconds instead of one second
13035 mDNSBool dodelay = (activationSpeed == SlowActivation) && (q->FlappingInterface1 == set->InterfaceID || q->FlappingInterface2 == set->InterfaceID);
13036 mDNSs32 initial = dodelay ? InitialQuestionInterval * QuestionIntervalStep2 : InitialQuestionInterval;
13037 mDNSs32 qdelay = dodelay ? kDefaultQueryDelayTimeForFlappingInterface : 0;
13038 if (dodelay) LogInfo("No cache records expired for %##s (%s); delaying questions by %d seconds", q->qname.c, DNSTypeName(q->qtype), qdelay);
13039
13040 if (!q->ThisQInterval || q->ThisQInterval > initial)
13041 {
13042 q->ThisQInterval = initial;
13043 q->RequestUnicast = kDefaultRequestUnicastCount;
13044 }
13045 q->LastQTime = m->timenow - q->ThisQInterval + qdelay;
13046 q->RecentAnswerPkts = 0;
13047 // Change the salt
13048 ReInitAnonInfo(&q->AnonInfo, &q->qname);
13049 SetNextQueryTime(m,q);
13050 }
13051 }
13052 }
13053
13054 // For all our non-specific authoritative resource records (and any dormant records specific to this interface)
13055 // we now need them to re-probe if necessary, and then re-announce.
13056 for (rr = m->ResourceRecords; rr; rr=rr->next)
13057 {
13058 if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID)
13059 {
13060 // Change the salt
13061 ReInitAnonInfo(&rr->resrec.AnonInfo, rr->resrec.name);
13062 mDNSCoreRestartRegistration(m, rr, numannounce);
13063 }
13064 }
13065#if APPLE_OSX_mDNSResponder && !TARGET_OS_IPHONE
13066 DNSSECProbe(m);
13067#endif
13068 }
13069
13070 RestartRecordGetZoneData(m);
13071
13072 mDNS_UpdateAllowSleep(m);
13073
13074 mDNS_Unlock(m);
13075 return(mStatus_NoError);
13076}
13077
13078// Note: mDNS_DeregisterInterface calls mDNS_Deregister_internal which can call a user callback, which may change
13079// the record list and/or question list.
13080// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
13081mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, InterfaceActivationSpeed activationSpeed)
13082{
13083 NetworkInterfaceInfo **p = &m->HostInterfaces;
13084 mDNSBool revalidate = mDNSfalse;
13085 NetworkInterfaceInfo *primary;
13086 NetworkInterfaceInfo *intf;
13087 AuthRecord *A;
13088
13089 mDNS_Lock(m);
13090
13091 // Find this record in our list
13092 while (*p && *p != set) p=&(*p)->next;
13093 if (!*p) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list"); mDNS_Unlock(m); return; }
13094
13095 mDNS_DeactivateNetWake_internal(m, set);
13096
13097 // Unlink this record from our list
13098 *p = (*p)->next;
13099 set->next = mDNSNULL;
13100
13101 if (!set->InterfaceActive)
13102 {
13103 // If this interface not the active member of its set, update the v4/v6Available flags for the active member
13104 for (intf = m->HostInterfaces; intf; intf = intf->next)
13105 if (intf->InterfaceActive && intf->InterfaceID == set->InterfaceID)
13106 UpdateInterfaceProtocols(m, intf);
13107 }
13108 else
13109 {
13110 intf = FirstInterfaceForID(m, set->InterfaceID);
13111 if (intf)
13112 {
13113 LogInfo("mDNS_DeregisterInterface: Another representative of InterfaceID %d %s (%#a) exists;"
13114 " making it active", IID(set->InterfaceID), set->ifname, &set->ip);
13115 if (intf->InterfaceActive)
13116 LogMsg("mDNS_DeregisterInterface: ERROR intf->InterfaceActive already set for %s (%#a)", set->ifname, &set->ip);
13117 intf->InterfaceActive = mDNStrue;
13118 UpdateInterfaceProtocols(m, intf);
13119
13120 if (intf->NetWake) mDNS_ActivateNetWake_internal(m, intf);
13121
13122 // See if another representative *of the same type* exists. If not, we mave have gone from
13123 // dual-stack to v6-only (or v4-only) so we need to reconfirm which records are still valid.
13124 for (intf = m->HostInterfaces; intf; intf = intf->next)
13125 if (intf->InterfaceID == set->InterfaceID && intf->ip.type == set->ip.type)
13126 break;
13127 if (!intf) revalidate = mDNStrue;
13128 }
13129 else
13130 {
13131 mDNSu32 slot;
13132 CacheGroup *cg;
13133 CacheRecord *rr;
13134 DNSQuestion *q;
13135
13136 LogInfo("mDNS_DeregisterInterface: Last representative of InterfaceID %d %s (%#a) deregistered;"
13137 " marking questions etc. dormant", IID(set->InterfaceID), set->ifname, &set->ip);
13138
13139 m->mDNSStats.InterfaceDown++;
13140
13141 if (set->McastTxRx && (activationSpeed == SlowActivation))
13142 {
13143 LogMsg("mDNS_DeregisterInterface: Frequent transitions for interface %s (%#a)", set->ifname, &set->ip);
13144 m->mDNSStats.InterfaceDownFlap++;
13145 }
13146
13147 // 1. Deactivate any questions specific to this interface, and tag appropriate questions
13148 // so that mDNS_RegisterInterface() knows how swiftly it needs to reactivate them
13149 for (q = m->Questions; q; q=q->next)
13150 {
13151 if (q->InterfaceID == set->InterfaceID) q->ThisQInterval = 0;
13152 if (!q->InterfaceID || q->InterfaceID == set->InterfaceID)
13153 {
13154 q->FlappingInterface2 = q->FlappingInterface1;
13155 q->FlappingInterface1 = set->InterfaceID; // Keep history of the last two interfaces to go away
13156 }
13157 }
13158
13159 // 2. Flush any cache records received on this interface
13160 revalidate = mDNSfalse; // Don't revalidate if we're flushing the records
13161 FORALL_CACHERECORDS(slot, cg, rr)
13162 {
13163 if (rr->resrec.InterfaceID == set->InterfaceID)
13164 {
13165 // If this interface is deemed flapping,
13166 // postpone deleting the cache records in case the interface comes back again
13167 if (set->McastTxRx && (activationSpeed == SlowActivation))
13168 {
13169 // For a flapping interface we want these records to go away after
13170 // kDefaultReconfirmTimeForFlappingInterface seconds if they are not reconfirmed.
13171 mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface);
13172 // We set UnansweredQueries = MaxUnansweredQueries so we don't waste time doing any queries for them --
13173 // if the interface does come back, any relevant questions will be reactivated anyway
13174 rr->UnansweredQueries = MaxUnansweredQueries;
13175 }
13176 else
13177 {
13178 mDNS_PurgeCacheResourceRecord(m, rr);
13179 }
13180 }
13181 }
13182 }
13183 }
13184
13185 // If we still have address records referring to this one, update them.
13186 // This is safe, because this NetworkInterfaceInfo has already been unlinked from the list,
13187 // so the call to FindFirstAdvertisedInterface() won’t accidentally find it.
13188 primary = FindFirstAdvertisedInterface(m);
13189 A = primary ? &primary->RR_A : mDNSNULL;
13190 for (intf = m->HostInterfaces; intf; intf = intf->next)
13191 if (intf->RR_A.RRSet == &set->RR_A)
13192 intf->RR_A.RRSet = A;
13193
13194 // If we were advertising on this interface, deregister those address and reverse-lookup records now
13195 if (set->Advertise) DeadvertiseInterface(m, set);
13196
13197 // If we have any cache records received on this interface that went away, then re-verify them.
13198 // In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
13199 // giving the false impression that there's an active representative of this interface when there really isn't.
13200 // Don't need to do this when shutting down, because *all* interfaces are about to go away
13201 if (revalidate && !m->ShutdownTime)
13202 {
13203 mDNSu32 slot;
13204 CacheGroup *cg;
13205 CacheRecord *rr;
13206 FORALL_CACHERECORDS(slot, cg, rr)
13207 if (rr->resrec.InterfaceID == set->InterfaceID)
13208 mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface);
13209 }
13210
13211 mDNS_UpdateAllowSleep(m);
13212
13213 mDNS_Unlock(m);
13214}
13215
13216mDNSlocal void SetAnonInfoSRS(ServiceRecordSet *sr, int NumSubTypes)
13217{
13218 int i, len;
13219
13220 if (!sr->AnonData)
13221 return;
13222
13223 len = mDNSPlatformStrLen(sr->AnonData);
13224 if (sr->RR_PTR.resrec.AnonInfo)
13225 {
13226 LogMsg("SetAnonInfoSRS: Freeing AnonInfo for PTR record %##s, should have been freed already", sr->RR_PTR.resrec.name->c);
13227 FreeAnonInfo(sr->RR_PTR.resrec.AnonInfo);
13228 }
13229 sr->RR_PTR.resrec.AnonInfo = AllocateAnonInfo(sr->RR_PTR.resrec.name, sr->AnonData, len, mDNSNULL);
13230 for (i=0; i<NumSubTypes; i++)
13231 {
13232 if (sr->SubTypes[i].resrec.AnonInfo)
13233 {
13234 LogMsg("SetAnonInfoSRS: Freeing AnonInfo for subtype record %##s, should have been freed already", sr->SubTypes[i].resrec.name->c);
13235 FreeAnonInfo(sr->SubTypes[i].resrec.AnonInfo);
13236 }
13237 sr->SubTypes[i].resrec.AnonInfo = AllocateAnonInfo(sr->SubTypes[i].resrec.name, sr->AnonData, len, mDNSNULL);
13238 }
13239}
13240
13241mDNSlocal void ResetAnonInfoSRS(ServiceRecordSet *sr, int NumSubTypes)
13242{
13243 int i;
13244
13245 if (!sr->AnonData)
13246 return;
13247 if (sr->RR_PTR.resrec.AnonInfo)
13248 {
13249 FreeAnonInfo(sr->RR_PTR.resrec.AnonInfo);
13250 sr->RR_PTR.resrec.AnonInfo = mDNSNULL;
13251 }
13252 for (i=0; i<NumSubTypes; i++)
13253 {
13254 if (sr->SubTypes[i].resrec.AnonInfo)
13255 {
13256 FreeAnonInfo(sr->SubTypes[i].resrec.AnonInfo);
13257 sr->SubTypes[i].resrec.AnonInfo = mDNSNULL;
13258 }
13259 }
13260}
13261
13262mDNSlocal void ServiceCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
13263{
13264 ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext;
13265 (void)m; // Unused parameter
13266
13267 #if MDNS_DEBUGMSGS
13268 {
13269 char *msg = "Unknown result";
13270 if (result == mStatus_NoError) msg = "Name Registered";
13271 else if (result == mStatus_NameConflict) msg = "Name Conflict";
13272 else if (result == mStatus_MemFree) msg = "Memory Free";
13273 debugf("ServiceCallback: %##s (%s) %s (%d)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result);
13274 }
13275 #endif
13276
13277 // Only pass on the NoError acknowledgement for the SRV record (when it finishes probing)
13278 if (result == mStatus_NoError && rr != &sr->RR_SRV) return;
13279
13280 // If we got a name conflict on either SRV or TXT, forcibly deregister this service, and record that we did that
13281 if (result == mStatus_NameConflict)
13282 {
13283 sr->Conflict = mDNStrue; // Record that this service set had a conflict
13284 mDNS_DeregisterService(m, sr); // Unlink the records from our list
13285 return;
13286 }
13287
13288 if (result == mStatus_MemFree)
13289 {
13290 // If the SRV/TXT/PTR records, or the _services._dns-sd._udp record, or any of the subtype PTR records,
13291 // are still in the process of deregistering, don't pass on the NameConflict/MemFree message until
13292 // every record is finished cleaning up.
13293 mDNSu32 i;
13294 ExtraResourceRecord *e = sr->Extras;
13295
13296 if (sr->RR_SRV.resrec.RecordType != kDNSRecordTypeUnregistered) return;
13297 if (sr->RR_TXT.resrec.RecordType != kDNSRecordTypeUnregistered) return;
13298 if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return;
13299 if (sr->RR_ADV.resrec.RecordType != kDNSRecordTypeUnregistered) return;
13300 for (i=0; i<sr->NumSubTypes; i++) if (sr->SubTypes[i].resrec.RecordType != kDNSRecordTypeUnregistered) return;
13301
13302 while (e)
13303 {
13304 if (e->r.resrec.RecordType != kDNSRecordTypeUnregistered) return;
13305 e = e->next;
13306 }
13307 ResetAnonInfoSRS(sr, sr->NumSubTypes);
13308
13309 // If this ServiceRecordSet was forcibly deregistered, and now its memory is ready for reuse,
13310 // then we can now report the NameConflict to the client
13311 if (sr->Conflict) result = mStatus_NameConflict;
13312
13313 }
13314
13315 LogInfo("ServiceCallback: All records %s for %##s", (result == mStatus_MemFree ? "Unregistered" : "Registered"), sr->RR_PTR.resrec.name->c);
13316 // CAUTION: MUST NOT do anything more with sr after calling sr->Callback(), because the client's callback
13317 // function is allowed to do anything, including deregistering this service and freeing its memory.
13318 if (sr->ServiceCallback)
13319 sr->ServiceCallback(m, sr, result);
13320}
13321
13322mDNSlocal void NSSCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
13323{
13324 ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext;
13325 if (sr->ServiceCallback)
13326 sr->ServiceCallback(m, sr, result);
13327}
13328
13329
13330// Derive AuthRecType from the kDNSServiceFlags* values.
13331mDNSlocal AuthRecType setAuthRecType(mDNSInterfaceID InterfaceID, mDNSu32 flags)
13332{
13333 AuthRecType artype;
13334
13335 if (InterfaceID == mDNSInterface_LocalOnly)
13336 artype = AuthRecordLocalOnly;
13337 else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE)
13338 artype = AuthRecordP2P;
13339 else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P)
13340 && (flags & kDNSServiceFlagsIncludeAWDL))
13341 artype = AuthRecordAnyIncludeAWDLandP2P;
13342 else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P))
13343 artype = AuthRecordAnyIncludeP2P;
13344 else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeAWDL))
13345 artype = AuthRecordAnyIncludeAWDL;
13346 else
13347 artype = AuthRecordAny;
13348
13349 return artype;
13350}
13351
13352// Used to derive the original D2D specific flags specified by the client in the registration
13353// when we don't have access to the original flag (kDNSServiceFlags*) values.
13354mDNSexport mDNSu32 deriveD2DFlagsFromAuthRecType(AuthRecType authRecType)
13355{
13356 mDNSu32 flags = 0;
13357 if ((authRecType == AuthRecordAnyIncludeP2P) || (authRecType == AuthRecordAnyIncludeAWDLandP2P))
13358 flags |= kDNSServiceFlagsIncludeP2P;
13359 else if ((authRecType == AuthRecordAnyIncludeAWDL) || (authRecType == AuthRecordAnyIncludeAWDLandP2P))
13360 flags |= kDNSServiceFlagsIncludeAWDL;
13361 return flags;
13362}
13363
13364// Note:
13365// Name is first label of domain name (any dots in the name are actual dots, not label separators)
13366// Type is service type (e.g. "_ipp._tcp.")
13367// Domain is fully qualified domain name (i.e. ending with a null label)
13368// We always register a TXT, even if it is empty (so that clients are not
13369// left waiting forever looking for a nonexistent record.)
13370// If the host parameter is mDNSNULL or the root domain (ASCII NUL),
13371// then the default host name (m->MulticastHostname) is automatically used
13372// If the optional target host parameter is set, then the storage it points to must remain valid for the lifetime of the service registration
13373mDNSexport mStatus mDNS_RegisterService(mDNS *const m, ServiceRecordSet *sr,
13374 const domainlabel *const name, const domainname *const type, const domainname *const domain,
13375 const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen,
13376 AuthRecord *SubTypes, mDNSu32 NumSubTypes,
13377 mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context, mDNSu32 flags)
13378{
13379 mStatus err;
13380 mDNSu32 i;
13381 mDNSu32 hostTTL;
13382 AuthRecType artype;
13383 mDNSu8 recordType = (flags & kDNSServiceFlagsKnownUnique) ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique;
13384
13385 sr->ServiceCallback = Callback;
13386 sr->ServiceContext = Context;
13387 sr->Conflict = mDNSfalse;
13388
13389 sr->Extras = mDNSNULL;
13390 sr->NumSubTypes = NumSubTypes;
13391 sr->SubTypes = SubTypes;
13392 sr->flags = flags;
13393
13394 artype = setAuthRecType(InterfaceID, flags);
13395
13396 // Initialize the AuthRecord objects to sane values
13397 // Need to initialize everything correctly *before* making the decision whether to do a RegisterNoSuchService and bail out
13398 mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeAdvisory, artype, ServiceCallback, sr);
13399 mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr);
13400
13401 if (flags & kDNSServiceFlagsWakeOnlyService)
13402 {
13403 sr->RR_PTR.AuthFlags = AuthFlagsWakeOnly;
13404 }
13405
13406 if (SameDomainName(type, (const domainname *) "\x4" "_ubd" "\x4" "_tcp"))
13407 hostTTL = kHostNameSmallTTL;
13408 else
13409 hostTTL = kHostNameTTL;
13410
13411 mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, hostTTL, recordType, artype, ServiceCallback, sr);
13412 mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kStandardTTL, recordType, artype, ServiceCallback, sr);
13413
13414 // If port number is zero, that means the client is really trying to do a RegisterNoSuchService
13415 if (mDNSIPPortIsZero(port))
13416 return(mDNS_RegisterNoSuchService(m, &sr->RR_SRV, name, type, domain, mDNSNULL, InterfaceID, NSSCallback, sr, flags));
13417
13418 // If the caller is registering an oversized TXT record,
13419 // it is the caller's responsibility to allocate a ServiceRecordSet structure that is large enough for it
13420 if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen)
13421 sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen;
13422
13423 // Set up the record names
13424 // For now we only create an advisory record for the main type, not for subtypes
13425 // We need to gain some operational experience before we decide if there's a need to create them for subtypes too
13426 if (ConstructServiceName(&sr->RR_ADV.namestorage, (const domainlabel*)"\x09_services", (const domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL)
13427 return(mStatus_BadParamErr);
13428 if (ConstructServiceName(&sr->RR_PTR.namestorage, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
13429 if (ConstructServiceName(&sr->RR_SRV.namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
13430 AssignDomainName(&sr->RR_TXT.namestorage, sr->RR_SRV.resrec.name);
13431
13432 // 1. Set up the ADV record rdata to advertise our service type
13433 AssignDomainName(&sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name);
13434
13435 // 2. Set up the PTR record rdata to point to our service name
13436 // We set up two additionals, so when a client asks for this PTR we automatically send the SRV and the TXT too
13437 // Note: uDNS registration code assumes that Additional1 points to the SRV record
13438 AssignDomainName(&sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name);
13439 sr->RR_PTR.Additional1 = &sr->RR_SRV;
13440 sr->RR_PTR.Additional2 = &sr->RR_TXT;
13441
13442 // 2a. Set up any subtype PTRs to point to our service name
13443 // If the client is using subtypes, it is the client's responsibility to have
13444 // already set the first label of the record name to the subtype being registered
13445 for (i=0; i<NumSubTypes; i++)
13446 {
13447 domainname st;
13448 AssignDomainName(&st, sr->SubTypes[i].resrec.name);
13449 st.c[1+st.c[0]] = 0; // Only want the first label, not the whole FQDN (particularly for mDNS_RenameAndReregisterService())
13450 AppendDomainName(&st, type);
13451 mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr);
13452 if (ConstructServiceName(&sr->SubTypes[i].namestorage, mDNSNULL, &st, domain) == mDNSNULL) return(mStatus_BadParamErr);
13453 AssignDomainName(&sr->SubTypes[i].resrec.rdata->u.name, &sr->RR_SRV.namestorage);
13454 sr->SubTypes[i].Additional1 = &sr->RR_SRV;
13455 sr->SubTypes[i].Additional2 = &sr->RR_TXT;
13456 }
13457
13458 SetAnonInfoSRS(sr, NumSubTypes);
13459
13460 // 3. Set up the SRV record rdata.
13461 sr->RR_SRV.resrec.rdata->u.srv.priority = 0;
13462 sr->RR_SRV.resrec.rdata->u.srv.weight = 0;
13463 sr->RR_SRV.resrec.rdata->u.srv.port = port;
13464
13465 // Setting AutoTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name
13466 if (host && host->c[0]) AssignDomainName(&sr->RR_SRV.resrec.rdata->u.srv.target, host);
13467 else { sr->RR_SRV.AutoTarget = Target_AutoHost; sr->RR_SRV.resrec.rdata->u.srv.target.c[0] = '\0'; }
13468
13469 // 4. Set up the TXT record rdata,
13470 // and set DependentOn because we're depending on the SRV record to find and resolve conflicts for us
13471 // Note: uDNS registration code assumes that DependentOn points to the SRV record
13472 if (txtinfo == mDNSNULL) sr->RR_TXT.resrec.rdlength = 0;
13473 else if (txtinfo != sr->RR_TXT.resrec.rdata->u.txt.c)
13474 {
13475 sr->RR_TXT.resrec.rdlength = txtlen;
13476 if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr);
13477 mDNSPlatformMemCopy(sr->RR_TXT.resrec.rdata->u.txt.c, txtinfo, txtlen);
13478 }
13479 sr->RR_TXT.DependentOn = &sr->RR_SRV;
13480
13481 mDNS_Lock(m);
13482 // It is important that we register SRV first. uDNS assumes that SRV is registered first so
13483 // that if the SRV cannot find a target, rest of the records that belong to this service
13484 // will not be activated.
13485 err = mDNS_Register_internal(m, &sr->RR_SRV);
13486 // If we can't register the SRV record due to errors, bail out. It has not been inserted in
13487 // any list and hence no need to deregister. We could probably do similar checks for other
13488 // records below and bail out. For now, this seems to be sufficient to address rdar://9304275
13489 if (err)
13490 {
13491 mDNS_Unlock(m);
13492 return err;
13493 }
13494 if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT);
13495 // We register the RR_PTR last, because we want to be sure that in the event of a forced call to
13496 // mDNS_StartExit, the RR_PTR will be the last one to be forcibly deregistered, since that is what triggers
13497 // the mStatus_MemFree callback to ServiceCallback, which in turn passes on the mStatus_MemFree back to
13498 // the client callback, which is then at liberty to free the ServiceRecordSet memory at will. We need to
13499 // make sure we've deregistered all our records and done any other necessary cleanup before that happens.
13500 if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV);
13501 for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]);
13502 if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR);
13503
13504 mDNS_Unlock(m);
13505
13506 if (err) mDNS_DeregisterService(m, sr);
13507 return(err);
13508}
13509
13510mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr,
13511 ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl, mDNSu32 flags)
13512{
13513 ExtraResourceRecord **e;
13514 mStatus status;
13515 AuthRecType artype;
13516 mDNSInterfaceID InterfaceID = sr->RR_PTR.resrec.InterfaceID;
13517 ResourceRecord *rr;
13518
13519 artype = setAuthRecType(InterfaceID, flags);
13520
13521 extra->next = mDNSNULL;
13522 mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID,
13523 extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, artype, ServiceCallback, sr);
13524 AssignDomainName(&extra->r.namestorage, sr->RR_SRV.resrec.name);
13525
13526 mDNS_Lock(m);
13527 rr = mDNSNULL;
13528 if (extra->r.resrec.rrtype == kDNSType_TXT)
13529 {
13530 if (sr->RR_TXT.resrec.RecordType & kDNSRecordTypeUniqueMask) rr = &sr->RR_TXT.resrec;
13531 }
13532 else if (extra->r.resrec.rrtype == kDNSType_SRV)
13533 {
13534 if (sr->RR_SRV.resrec.RecordType & kDNSRecordTypeUniqueMask) rr = &sr->RR_SRV.resrec;
13535 }
13536
13537 if (!rr)
13538 {
13539 ExtraResourceRecord *srExtra;
13540
13541 for (srExtra = sr->Extras; srExtra; srExtra = srExtra->next)
13542 {
13543 if ((srExtra->r.resrec.rrtype == extra->r.resrec.rrtype) && (srExtra->r.resrec.RecordType & kDNSRecordTypeUniqueMask))
13544 {
13545 rr = &srExtra->r.resrec;
13546 break;
13547 }
13548 }
13549 }
13550
13551 if (rr && (extra->r.resrec.rroriginalttl != rr->rroriginalttl))
13552 {
13553 LogMsg("mDNS_AddRecordToService: Correcting TTL from %4d to %4d for %s",
13554 extra->r.resrec.rroriginalttl, rr->rroriginalttl, RRDisplayString(m, &extra->r.resrec));
13555 extra->r.resrec.rroriginalttl = rr->rroriginalttl;
13556 }
13557
13558 e = &sr->Extras;
13559 while (*e) e = &(*e)->next;
13560
13561 extra->r.DependentOn = &sr->RR_SRV;
13562
13563 debugf("mDNS_AddRecordToService adding record to %##s %s %d",
13564 extra->r.resrec.name->c, DNSTypeName(extra->r.resrec.rrtype), extra->r.resrec.rdlength);
13565
13566 status = mDNS_Register_internal(m, &extra->r);
13567 if (status == mStatus_NoError) *e = extra;
13568
13569 mDNS_Unlock(m);
13570 return(status);
13571}
13572
13573mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra,
13574 mDNSRecordCallback MemFreeCallback, void *Context)
13575{
13576 ExtraResourceRecord **e;
13577 mStatus status;
13578
13579 mDNS_Lock(m);
13580 e = &sr->Extras;
13581 while (*e && *e != extra) e = &(*e)->next;
13582 if (!*e)
13583 {
13584 debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra->r.resrec.name->c);
13585 status = mStatus_BadReferenceErr;
13586 }
13587 else
13588 {
13589 debugf("mDNS_RemoveRecordFromService removing record from %##s", extra->r.resrec.name->c);
13590 extra->r.RecordCallback = MemFreeCallback;
13591 extra->r.RecordContext = Context;
13592 *e = (*e)->next;
13593 status = mDNS_Deregister_internal(m, &extra->r, mDNS_Dereg_normal);
13594 }
13595 mDNS_Unlock(m);
13596 return(status);
13597}
13598
13599mDNSexport mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname)
13600{
13601 // Note: Don't need to use mDNS_Lock(m) here, because this code is just using public routines
13602 // mDNS_RegisterService() and mDNS_AddRecordToService(), which do the right locking internally.
13603 domainlabel name1, name2;
13604 domainname type, domain;
13605 const domainname *host = sr->RR_SRV.AutoTarget ? mDNSNULL : &sr->RR_SRV.resrec.rdata->u.srv.target;
13606 ExtraResourceRecord *extras = sr->Extras;
13607 mStatus err;
13608
13609 DeconstructServiceName(sr->RR_SRV.resrec.name, &name1, &type, &domain);
13610 if (!newname)
13611 {
13612 name2 = name1;
13613 IncrementLabelSuffix(&name2, mDNStrue);
13614 newname = &name2;
13615 }
13616
13617 if (SameDomainName(&domain, &localdomain))
13618 debugf("%##s service renamed from \"%#s\" to \"%#s\"", type.c, name1.c, newname->c);
13619 else debugf("%##s service (domain %##s) renamed from \"%#s\" to \"%#s\"",type.c, domain.c, name1.c, newname->c);
13620
13621 err = mDNS_RegisterService(m, sr, newname, &type, &domain,
13622 host, sr->RR_SRV.resrec.rdata->u.srv.port, sr->RR_TXT.resrec.rdata->u.txt.c, sr->RR_TXT.resrec.rdlength,
13623 sr->SubTypes, sr->NumSubTypes,
13624 sr->RR_PTR.resrec.InterfaceID, sr->ServiceCallback, sr->ServiceContext, sr->flags);
13625
13626 // mDNS_RegisterService() just reset sr->Extras to NULL.
13627 // Fortunately we already grabbed ourselves a copy of this pointer (above), so we can now run
13628 // through the old list of extra records, and re-add them to our freshly created service registration
13629 while (!err && extras)
13630 {
13631 ExtraResourceRecord *e = extras;
13632 extras = extras->next;
13633 err = mDNS_AddRecordToService(m, sr, e, e->r.resrec.rdata, e->r.resrec.rroriginalttl, 0);
13634 }
13635
13636 return(err);
13637}
13638
13639// Note: mDNS_DeregisterService calls mDNS_Deregister_internal which can call a user callback,
13640// which may change the record list and/or question list.
13641// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
13642mDNSexport mStatus mDNS_DeregisterService_drt(mDNS *const m, ServiceRecordSet *sr, mDNS_Dereg_type drt)
13643{
13644 // If port number is zero, that means this was actually registered using mDNS_RegisterNoSuchService()
13645 if (mDNSIPPortIsZero(sr->RR_SRV.resrec.rdata->u.srv.port)) return(mDNS_DeregisterNoSuchService(m, &sr->RR_SRV));
13646
13647 if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered)
13648 {
13649 debugf("Service set for %##s already deregistered", sr->RR_SRV.resrec.name->c);
13650 return(mStatus_BadReferenceErr);
13651 }
13652 else if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeDeregistering)
13653 {
13654 LogInfo("Service set for %##s already in the process of deregistering", sr->RR_SRV.resrec.name->c);
13655 // Avoid race condition:
13656 // If a service gets a conflict, then we set the Conflict flag to tell us to generate
13657 // an mStatus_NameConflict message when we get the mStatus_MemFree for our PTR record.
13658 // If the client happens to deregister the service in the middle of that process, then
13659 // we clear the flag back to the normal state, so that we deliver a plain mStatus_MemFree
13660 // instead of incorrectly promoting it to mStatus_NameConflict.
13661 // This race condition is exposed particularly when the conformance test generates
13662 // a whole batch of simultaneous conflicts across a range of services all advertised
13663 // using the same system default name, and if we don't take this precaution then
13664 // we end up incrementing m->nicelabel multiple times instead of just once.
13665 // <rdar://problem/4060169> Bug when auto-renaming Computer Name after name collision
13666 sr->Conflict = mDNSfalse;
13667 return(mStatus_NoError);
13668 }
13669 else
13670 {
13671 mDNSu32 i;
13672 mStatus status;
13673 ExtraResourceRecord *e;
13674 mDNS_Lock(m);
13675 e = sr->Extras;
13676
13677 // We use mDNS_Dereg_repeat because, in the event of a collision, some or all of the
13678 // SRV, TXT, or Extra records could have already been automatically deregistered, and that's okay
13679 mDNS_Deregister_internal(m, &sr->RR_SRV, mDNS_Dereg_repeat);
13680 mDNS_Deregister_internal(m, &sr->RR_TXT, mDNS_Dereg_repeat);
13681
13682 mDNS_Deregister_internal(m, &sr->RR_ADV, drt);
13683
13684 // We deregister all of the extra records, but we leave the sr->Extras list intact
13685 // in case the client wants to do a RenameAndReregister and reinstate the registration
13686 while (e)
13687 {
13688 mDNS_Deregister_internal(m, &e->r, mDNS_Dereg_repeat);
13689 e = e->next;
13690 }
13691
13692 for (i=0; i<sr->NumSubTypes; i++)
13693 mDNS_Deregister_internal(m, &sr->SubTypes[i], drt);
13694
13695 status = mDNS_Deregister_internal(m, &sr->RR_PTR, drt);
13696 mDNS_Unlock(m);
13697 return(status);
13698 }
13699}
13700
13701// Create a registration that asserts that no such service exists with this name.
13702// This can be useful where there is a given function is available through several protocols.
13703// For example, a printer called "Stuart's Printer" may implement printing via the "pdl-datastream" and "IPP"
13704// protocols, but not via "LPR". In this case it would be prudent for the printer to assert the non-existence of an
13705// "LPR" service called "Stuart's Printer". Without this precaution, another printer than offers only "LPR" printing
13706// could inadvertently advertise its service under the same name "Stuart's Printer", which might be confusing for users.
13707mDNSexport mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr,
13708 const domainlabel *const name, const domainname *const type, const domainname *const domain,
13709 const domainname *const host,
13710 const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context, mDNSu32 flags)
13711{
13712 AuthRecType artype;
13713
13714 artype = setAuthRecType(InterfaceID, flags);
13715
13716 mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kHostNameTTL, kDNSRecordTypeUnique, artype, Callback, Context);
13717 if (ConstructServiceName(&rr->namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
13718 rr->resrec.rdata->u.srv.priority = 0;
13719 rr->resrec.rdata->u.srv.weight = 0;
13720 rr->resrec.rdata->u.srv.port = zeroIPPort;
13721 if (host && host->c[0]) AssignDomainName(&rr->resrec.rdata->u.srv.target, host);
13722 else rr->AutoTarget = Target_AutoHost;
13723 return(mDNS_Register(m, rr));
13724}
13725
13726mDNSexport mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr,
13727 mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname)
13728{
13729 AuthRecType artype;
13730
13731 if (InterfaceID == mDNSInterface_LocalOnly)
13732 artype = AuthRecordLocalOnly;
13733 else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE)
13734 artype = AuthRecordP2P;
13735 else
13736 artype = AuthRecordAny;
13737 mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, mDNSNULL, mDNSNULL);
13738 if (!MakeDomainNameFromDNSNameString(&rr->namestorage, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
13739 if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr);
13740 return(mDNS_Register(m, rr));
13741}
13742
13743mDNSlocal mDNSBool mDNS_IdUsedInResourceRecordsList(mDNS * const m, mDNSOpaque16 id)
13744{
13745 AuthRecord *r;
13746 for (r = m->ResourceRecords; r; r=r->next) if (mDNSSameOpaque16(id, r->updateid)) return mDNStrue;
13747 return mDNSfalse;
13748}
13749
13750mDNSlocal mDNSBool mDNS_IdUsedInQuestionsList(mDNS * const m, mDNSOpaque16 id)
13751{
13752 DNSQuestion *q;
13753 for (q = m->Questions; q; q=q->next) if (mDNSSameOpaque16(id, q->TargetQID)) return mDNStrue;
13754 return mDNSfalse;
13755}
13756
13757mDNSexport mDNSOpaque16 mDNS_NewMessageID(mDNS * const m)
13758{
13759 mDNSOpaque16 id;
13760 int i;
13761
13762 for (i=0; i<10; i++)
13763 {
13764 id = mDNSOpaque16fromIntVal(1 + (mDNSu16)mDNSRandom(0xFFFE));
13765 if (!mDNS_IdUsedInResourceRecordsList(m, id) && !mDNS_IdUsedInQuestionsList(m, id)) break;
13766 }
13767
13768 debugf("mDNS_NewMessageID: %5d", mDNSVal16(id));
13769
13770 return id;
13771}
13772
13773// ***************************************************************************
13774#if COMPILER_LIKES_PRAGMA_MARK
13775#pragma mark -
13776#pragma mark - Sleep Proxy Server
13777#endif
13778
13779mDNSlocal void RestartARPProbing(mDNS *const m, AuthRecord *const rr)
13780{
13781 // If we see an ARP from a machine we think is sleeping, then either
13782 // (i) the machine has woken, or
13783 // (ii) it's just a stray old packet from before the machine slept
13784 // To handle the second case, we reset ProbeCount, so we'll suppress our own answers for a while, to avoid
13785 // generating ARP conflicts with a waking machine, and set rr->LastAPTime so we'll start probing again in 10 seconds.
13786 // If the machine has just woken then we'll discard our records when we see the first new mDNS probe from that machine.
13787 // If it was a stray old packet, then after 10 seconds we'll probe again and then start answering ARPs again. In this case we *do*
13788 // need to send new ARP Announcements, because the owner's ARP broadcasts will have updated neighboring ARP caches, so we need to
13789 // re-assert our (temporary) ownership of that IP address in order to receive subsequent packets addressed to that IPv4 address.
13790
13791 rr->resrec.RecordType = kDNSRecordTypeUnique;
13792 rr->ProbeCount = DefaultProbeCountForTypeUnique;
13793 rr->ProbeRestartCount++;
13794
13795 // If we haven't started announcing yet (and we're not already in ten-second-delay mode) the machine is probably
13796 // still going to sleep, so we just reset rr->ProbeCount so we'll continue probing until it stops responding.
13797 // If we *have* started announcing, the machine is probably in the process of waking back up, so in that case
13798 // we're more cautious and we wait ten seconds before probing it again. We do this because while waking from
13799 // sleep, some network interfaces tend to lose or delay inbound packets, and without this delay, if the waking machine
13800 // didn't answer our three probes within three seconds then we'd announce and cause it an unnecessary address conflict.
13801 if (rr->AnnounceCount == InitialAnnounceCount && m->timenow - rr->LastAPTime >= 0)
13802 InitializeLastAPTime(m, rr);
13803 else
13804 {
13805 rr->AnnounceCount = InitialAnnounceCount;
13806 rr->ThisAPInterval = mDNSPlatformOneSecond;
13807 rr->LastAPTime = m->timenow + mDNSPlatformOneSecond * 9; // Send first packet at rr->LastAPTime + rr->ThisAPInterval, i.e. 10 seconds from now
13808 SetNextAnnounceProbeTime(m, rr);
13809 }
13810}
13811
13812mDNSlocal void mDNSCoreReceiveRawARP(mDNS *const m, const ARP_EthIP *const arp, const mDNSInterfaceID InterfaceID)
13813{
13814 static const mDNSOpaque16 ARP_op_request = { { 0, 1 } };
13815 AuthRecord *rr;
13816 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID);
13817 if (!intf) return;
13818
13819 mDNS_Lock(m);
13820
13821 // Pass 1:
13822 // Process ARP Requests and Probes (but not Announcements), and generate an ARP Reply if necessary.
13823 // We also process ARPs from our own kernel (and 'answer' them by injecting a local ARP table entry)
13824 // We ignore ARP Announcements here -- Announcements are not questions, they're assertions, so we don't need to answer them.
13825 // The times we might need to react to an ARP Announcement are:
13826 // (i) as an indication that the host in question has not gone to sleep yet (so we should delay beginning to proxy for it) or
13827 // (ii) if it's a conflicting Announcement from another host
13828 // -- and we check for these in Pass 2 below.
13829 if (mDNSSameOpaque16(arp->op, ARP_op_request) && !mDNSSameIPv4Address(arp->spa, arp->tpa))
13830 {
13831 for (rr = m->ResourceRecords; rr; rr=rr->next)
13832 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering &&
13833 rr->AddressProxy.type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->AddressProxy.ip.v4, arp->tpa))
13834 {
13835 static const char msg1[] = "ARP Req from owner -- re-probing";
13836 static const char msg2[] = "Ignoring ARP Request from ";
13837 static const char msg3[] = "Creating Local ARP Cache entry ";
13838 static const char msg4[] = "Answering ARP Request from ";
13839 const char *const msg = mDNSSameEthAddress(&arp->sha, &rr->WakeUp.IMAC) ? msg1 :
13840 (rr->AnnounceCount == InitialAnnounceCount) ? msg2 :
13841 mDNSSameEthAddress(&arp->sha, &intf->MAC) ? msg3 : msg4;
13842 LogMsg("Arp %-7s %s %.6a %.4a for %.4a -- H-MAC %.6a I-MAC %.6a %s",
13843 intf->ifname, msg, arp->sha.b, arp->spa.b, arp->tpa.b,
13844 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
13845 if (msg == msg1)
13846 {
13847 if ( rr->ProbeRestartCount < MAX_PROBE_RESTARTS)
13848 RestartARPProbing(m, rr);
13849 else
13850 LogSPS("Reached maximum number of restarts for probing - %s", ARDisplayString(m,rr));
13851 }
13852 else if (msg == msg3)
13853 {
13854 mDNSPlatformSetLocalAddressCacheEntry(&rr->AddressProxy, &rr->WakeUp.IMAC, InterfaceID);
13855 }
13856 else if (msg == msg4)
13857 {
13858 SendARP(m, 2, rr, (mDNSv4Addr *)arp->tpa.b, &arp->sha, (mDNSv4Addr *)arp->spa.b, &arp->sha);
13859 }
13860 }
13861 }
13862
13863 // Pass 2:
13864 // For all types of ARP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding.
13865 // (Strictly speaking we're only checking Announcement/Request/Reply packets, since ARP Probes have zero Sender IP address,
13866 // so by definition (and by design) they can never conflict with any real (i.e. non-zero) IP address).
13867 // We ignore ARPs we sent ourselves (Sender MAC address is our MAC address) because our own proxy ARPs do not constitute a conflict that we need to handle.
13868 // If we see an apparently conflicting ARP, we check the sender hardware address:
13869 // If the sender hardware address is the original owner this is benign, so we just suppress our own proxy answering for a while longer.
13870 // If the sender hardware address is *not* the original owner, then this is a conflict, and we need to wake the sleeping machine to handle it.
13871 if (mDNSSameEthAddress(&arp->sha, &intf->MAC))
13872 debugf("ARP from self for %.4a", arp->tpa.b);
13873 else
13874 {
13875 if (!mDNSSameIPv4Address(arp->spa, zerov4Addr))
13876 for (rr = m->ResourceRecords; rr; rr=rr->next)
13877 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering &&
13878 rr->AddressProxy.type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->AddressProxy.ip.v4, arp->spa) && (rr->ProbeRestartCount < MAX_PROBE_RESTARTS))
13879 {
13880 if (mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC))
13881 {
13882 LogMsg("%-7s ARP from %.6a %.4a for %.4a -- Invalid H-MAC %.6a I-MAC %.6a %s", intf->ifname,
13883 arp->sha.b, arp->spa.b, arp->tpa.b, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
13884 }
13885 else
13886 {
13887 RestartARPProbing(m, rr);
13888 if (mDNSSameEthAddress(&arp->sha, &rr->WakeUp.IMAC))
13889 {
13890 LogMsg("%-7s ARP %s from owner %.6a %.4a for %-15.4a -- re-starting probing for %s", intf->ifname,
13891 mDNSSameIPv4Address(arp->spa, arp->tpa) ? "Announcement " : mDNSSameOpaque16(arp->op, ARP_op_request) ? "Request " : "Response ",
13892 arp->sha.b, arp->spa.b, arp->tpa.b, ARDisplayString(m, rr));
13893 }
13894 else
13895 {
13896 LogMsg("%-7s Conflicting ARP from %.6a %.4a for %.4a -- waking H-MAC %.6a I-MAC %.6a %s", intf->ifname,
13897 arp->sha.b, arp->spa.b, arp->tpa.b, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
13898 ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC);
13899 }
13900 }
13901 }
13902 }
13903
13904 mDNS_Unlock(m);
13905}
13906
13907/*
13908 // Option 1 is Source Link Layer Address Option
13909 // Option 2 is Target Link Layer Address Option
13910 mDNSlocal const mDNSEthAddr *GetLinkLayerAddressOption(const IPv6NDP *const ndp, const mDNSu8 *const end, mDNSu8 op)
13911 {
13912 const mDNSu8 *options = (mDNSu8 *)(ndp+1);
13913 while (options < end)
13914 {
13915 debugf("NDP Option %02X len %2d %d", options[0], options[1], end - options);
13916 if (options[0] == op && options[1] == 1) return (const mDNSEthAddr*)(options+2);
13917 options += options[1] * 8;
13918 }
13919 return mDNSNULL;
13920 }
13921 */
13922
13923mDNSlocal void mDNSCoreReceiveRawND(mDNS *const m, const mDNSEthAddr *const sha, const mDNSv6Addr *spa,
13924 const IPv6NDP *const ndp, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID)
13925{
13926 AuthRecord *rr;
13927 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID);
13928 if (!intf) return;
13929
13930 mDNS_Lock(m);
13931
13932 // Pass 1: Process Neighbor Solicitations, and generate a Neighbor Advertisement if necessary.
13933 if (ndp->type == NDP_Sol)
13934 {
13935 //const mDNSEthAddr *const sha = GetLinkLayerAddressOption(ndp, end, NDP_SrcLL);
13936 (void)end;
13937 for (rr = m->ResourceRecords; rr; rr=rr->next)
13938 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering &&
13939 rr->AddressProxy.type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->AddressProxy.ip.v6, ndp->target))
13940 {
13941 static const char msg1[] = "NDP Req from owner -- re-probing";
13942 static const char msg2[] = "Ignoring NDP Request from ";
13943 static const char msg3[] = "Creating Local NDP Cache entry ";
13944 static const char msg4[] = "Answering NDP Request from ";
13945 static const char msg5[] = "Answering NDP Probe from ";
13946 const char *const msg = sha && mDNSSameEthAddress(sha, &rr->WakeUp.IMAC) ? msg1 :
13947 (rr->AnnounceCount == InitialAnnounceCount) ? msg2 :
13948 sha && mDNSSameEthAddress(sha, &intf->MAC) ? msg3 :
13949 spa && mDNSIPv6AddressIsZero(*spa) ? msg4 : msg5;
13950 LogSPS("%-7s %s %.6a %.16a for %.16a -- H-MAC %.6a I-MAC %.6a %s",
13951 intf->ifname, msg, sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
13952 if (msg == msg1)
13953 {
13954 if (rr->ProbeRestartCount < MAX_PROBE_RESTARTS)
13955 RestartARPProbing(m, rr);
13956 else
13957 LogSPS("Reached maximum number of restarts for probing - %s", ARDisplayString(m,rr));
13958 }
13959 else if (msg == msg3)
13960 mDNSPlatformSetLocalAddressCacheEntry(&rr->AddressProxy, &rr->WakeUp.IMAC, InterfaceID);
13961 else if (msg == msg4)
13962 SendNDP(m, NDP_Adv, NDP_Solicited, rr, &ndp->target, mDNSNULL, spa, sha);
13963 else if (msg == msg5)
13964 SendNDP(m, NDP_Adv, 0, rr, &ndp->target, mDNSNULL, &AllHosts_v6, &AllHosts_v6_Eth);
13965 }
13966 }
13967
13968 // Pass 2: For all types of NDP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding.
13969 if (mDNSSameEthAddress(sha, &intf->MAC))
13970 debugf("NDP from self for %.16a", &ndp->target);
13971 else
13972 {
13973 // For Neighbor Advertisements we check the Target address field, not the actual IPv6 source address.
13974 // When a machine has both link-local and routable IPv6 addresses, it may send NDP packets making assertions
13975 // about its routable IPv6 address, using its link-local address as the source address for all NDP packets.
13976 // Hence it is the NDP target address we care about, not the actual packet source address.
13977 if (ndp->type == NDP_Adv) spa = &ndp->target;
13978 if (!mDNSSameIPv6Address(*spa, zerov6Addr))
13979 for (rr = m->ResourceRecords; rr; rr=rr->next)
13980 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering &&
13981 rr->AddressProxy.type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->AddressProxy.ip.v6, *spa) && (rr->ProbeRestartCount < MAX_PROBE_RESTARTS))
13982 {
13983 if (mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC))
13984 {
13985 LogSPS("%-7s NDP from %.6a %.16a for %.16a -- Invalid H-MAC %.6a I-MAC %.6a %s", intf->ifname,
13986 sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
13987 }
13988 else
13989 {
13990 RestartARPProbing(m, rr);
13991 if (mDNSSameEthAddress(sha, &rr->WakeUp.IMAC))
13992 {
13993 LogSPS("%-7s NDP %s from owner %.6a %.16a for %.16a -- re-starting probing for %s", intf->ifname,
13994 ndp->type == NDP_Sol ? "Solicitation " : "Advertisement", sha, spa, &ndp->target, ARDisplayString(m, rr));
13995 }
13996 else
13997 {
13998 LogMsg("%-7s Conflicting NDP from %.6a %.16a for %.16a -- waking H-MAC %.6a I-MAC %.6a %s", intf->ifname,
13999 sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr));
14000 ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC);
14001 }
14002 }
14003 }
14004 }
14005
14006 mDNS_Unlock(m);
14007}
14008
14009mDNSlocal void mDNSCoreReceiveRawTransportPacket(mDNS *const m, const mDNSEthAddr *const sha, const mDNSAddr *const src, const mDNSAddr *const dst, const mDNSu8 protocol,
14010 const mDNSu8 *const p, const TransportLayerPacket *const t, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID, const mDNSu16 len)
14011{
14012 const mDNSIPPort port = (protocol == 0x06) ? t->tcp.dst : (protocol == 0x11) ? t->udp.dst : zeroIPPort;
14013 mDNSBool wake = mDNSfalse;
14014 mDNSBool kaWake = mDNSfalse;
14015
14016 switch (protocol)
14017 {
14018 #define XX wake ? "Received" : "Ignoring", end-p
14019 case 0x01: LogSPS("Ignoring %d-byte ICMP from %#a to %#a", end-p, src, dst);
14020 break;
14021
14022 case 0x06: {
14023 AuthRecord *kr;
14024 mDNSu32 seq, ack;
14025 #define TH_FIN 0x01
14026 #define TH_SYN 0x02
14027 #define TH_RST 0x04
14028 #define TH_ACK 0x10
14029
14030 kr = mDNS_MatchKeepaliveInfo(m, dst, src, port, t->tcp.src, &seq, &ack);
14031 if (kr)
14032 {
14033 LogSPS("mDNSCoreReceiveRawTransportPacket: Found a Keepalive record from %#a:%d to %#a:%d", src, mDNSVal16(t->tcp.src), dst, mDNSVal16(port));
14034 // Plan to wake if
14035 // (a) RST or FIN is set (the keepalive that we sent could have caused a reset)
14036 // (b) packet that contains new data and acks a sequence number higher than the one
14037 // we have been sending in the keepalive
14038
14039 wake = ((t->tcp.flags & TH_RST) || (t->tcp.flags & TH_FIN)) ;
14040 if (!wake)
14041 {
14042 mDNSu8 *ptr;
14043 mDNSu32 pseq, pack;
14044 mDNSBool data = mDNSfalse;
14045 mDNSu8 tcphlen;
14046
14047 // Convert to host order
14048 ptr = (mDNSu8 *)&seq;
14049 seq = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
14050
14051 ptr = (mDNSu8 *)&ack;
14052 ack = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
14053
14054 pseq = t->tcp.seq;
14055 ptr = (mDNSu8 *)&pseq;
14056 pseq = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
14057
14058 pack = t->tcp.ack;
14059 ptr = (mDNSu8 *)&pack;
14060 pack = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
14061
14062 // If the other side is acking one more than our sequence number (keepalive is one
14063 // less than the last valid sequence sent) and it's sequence is more than what we
14064 // acked before
14065 //if (end - p - 34 - ((t->tcp.offset >> 4) * 4) > 0) data = mDNStrue;
14066 tcphlen = ((t->tcp.offset >> 4) * 4);
14067 if (end - ((mDNSu8 *)t + tcphlen) > 0) data = mDNStrue;
14068 wake = ((int)(pack - seq) > 0) && ((int)(pseq - ack) >= 0) && data;
14069
14070 // If we got a regular keepalive on a connection that was registed with the KeepAlive API, respond with an ACK
14071 if ((t->tcp.flags & TH_ACK) && (data == mDNSfalse) &&
14072 ((int)(ack - pseq) == 1))
14073 {
14074 // Send an ACK;
14075 mDNS_SendKeepaliveACK(m, kr);
14076 }
14077 LogSPS("mDNSCoreReceiveRawTransportPacket: End %p, hlen %d, Datalen %d, pack %u, seq %u, pseq %u, ack %u, wake %d",
14078 end, tcphlen, end - ((mDNSu8 *)t + tcphlen), pack, seq, pseq, ack, wake);
14079 }
14080 else { LogSPS("mDNSCoreReceiveRawTransportPacket: waking because of RST or FIN th_flags %d", t->tcp.flags); }
14081 kaWake = wake;
14082 }
14083 else
14084 {
14085 // Plan to wake if
14086 // (a) RST is not set, AND
14087 // (b) packet is SYN, SYN+FIN, or plain data packet (no SYN or FIN). We won't wake for FIN alone.
14088 wake = (!(t->tcp.flags & TH_RST) && (t->tcp.flags & (TH_FIN|TH_SYN)) != TH_FIN);
14089
14090 // For now, to reduce spurious wakeups, we wake only for TCP SYN,
14091 // except for ssh connections, where we'll wake for plain data packets too
14092 if (!mDNSSameIPPort(port, SSHPort) && !(t->tcp.flags & 2)) wake = mDNSfalse;
14093
14094 LogSPS("%s %d-byte TCP from %#a:%d to %#a:%d%s%s%s", XX,
14095 src, mDNSVal16(t->tcp.src), dst, mDNSVal16(port),
14096 (t->tcp.flags & 2) ? " SYN" : "",
14097 (t->tcp.flags & 1) ? " FIN" : "",
14098 (t->tcp.flags & 4) ? " RST" : "");
14099 }
14100 break;
14101 }
14102
14103 case 0x11: {
14104 #define ARD_AsNumber 3283
14105 static const mDNSIPPort ARD = { { ARD_AsNumber >> 8, ARD_AsNumber & 0xFF } };
14106 const mDNSu16 udplen = (mDNSu16)((mDNSu16)t->bytes[4] << 8 | t->bytes[5]); // Length *including* 8-byte UDP header
14107 if (udplen >= sizeof(UDPHeader))
14108 {
14109 const mDNSu16 datalen = udplen - sizeof(UDPHeader);
14110 wake = mDNStrue;
14111
14112 // For Back to My Mac UDP port 4500 (IPSEC) packets, we do some special handling
14113 if (mDNSSameIPPort(port, IPSECPort))
14114 {
14115 // Specifically ignore NAT keepalive packets
14116 if (datalen == 1 && end >= &t->bytes[9] && t->bytes[8] == 0xFF) wake = mDNSfalse;
14117 else
14118 {
14119 // Skip over the Non-ESP Marker if present
14120 const mDNSBool NonESP = (end >= &t->bytes[12] && t->bytes[8] == 0 && t->bytes[9] == 0 && t->bytes[10] == 0 && t->bytes[11] == 0);
14121 const IKEHeader *const ike = (IKEHeader *)(t + (NonESP ? 12 : 8));
14122 const mDNSu16 ikelen = datalen - (NonESP ? 4 : 0);
14123 if (ikelen >= sizeof(IKEHeader) && end >= ((mDNSu8 *)ike) + sizeof(IKEHeader))
14124 if ((ike->Version & 0x10) == 0x10)
14125 {
14126 // ExchangeType == 5 means 'Informational' <http://www.ietf.org/rfc/rfc2408.txt>
14127 // ExchangeType == 34 means 'IKE_SA_INIT' <http://www.iana.org/assignments/ikev2-parameters>
14128 if (ike->ExchangeType == 5 || ike->ExchangeType == 34) wake = mDNSfalse;
14129 LogSPS("%s %d-byte IKE ExchangeType %d", XX, ike->ExchangeType);
14130 }
14131 }
14132 }
14133
14134 // For now, because we haven't yet worked out a clean elegant way to do this, we just special-case the
14135 // Apple Remote Desktop port number -- we ignore all packets to UDP 3283 (the "Net Assistant" port),
14136 // except for Apple Remote Desktop's explicit manual wakeup packet, which looks like this:
14137 // UDP header (8 bytes)
14138 // Payload: 13 88 00 6a 41 4e 41 20 (8 bytes) ffffffffffff (6 bytes) 16xMAC (96 bytes) = 110 bytes total
14139 if (mDNSSameIPPort(port, ARD)) wake = (datalen >= 110 && end >= &t->bytes[10] && t->bytes[8] == 0x13 && t->bytes[9] == 0x88);
14140
14141 LogSPS("%s %d-byte UDP from %#a:%d to %#a:%d", XX, src, mDNSVal16(t->udp.src), dst, mDNSVal16(port));
14142 }
14143 }
14144 break;
14145
14146 case 0x3A: if (&t->bytes[len] <= end)
14147 {
14148 mDNSu16 checksum = IPv6CheckSum(&src->ip.v6, &dst->ip.v6, protocol, t->bytes, len);
14149 if (!checksum) mDNSCoreReceiveRawND(m, sha, &src->ip.v6, &t->ndp, &t->bytes[len], InterfaceID);
14150 else LogInfo("IPv6CheckSum bad %04X %02X%02X from %#a to %#a", checksum, t->bytes[2], t->bytes[3], src, dst);
14151 }
14152 break;
14153
14154 default: LogSPS("Ignoring %d-byte IP packet unknown protocol %d from %#a to %#a", end-p, protocol, src, dst);
14155 break;
14156 }
14157
14158 if (wake)
14159 {
14160 AuthRecord *rr, *r2;
14161
14162 mDNS_Lock(m);
14163 for (rr = m->ResourceRecords; rr; rr=rr->next)
14164 if (rr->resrec.InterfaceID == InterfaceID &&
14165 rr->resrec.RecordType != kDNSRecordTypeDeregistering &&
14166 rr->AddressProxy.type && mDNSSameAddress(&rr->AddressProxy, dst))
14167 {
14168 const mDNSu8 *const tp = (protocol == 6) ? (const mDNSu8 *)"\x4_tcp" : (const mDNSu8 *)"\x4_udp";
14169 for (r2 = m->ResourceRecords; r2; r2=r2->next)
14170 if (r2->resrec.InterfaceID == InterfaceID && mDNSSameEthAddress(&r2->WakeUp.HMAC, &rr->WakeUp.HMAC) &&
14171 r2->resrec.RecordType != kDNSRecordTypeDeregistering &&
14172 r2->resrec.rrtype == kDNSType_SRV && mDNSSameIPPort(r2->resrec.rdata->u.srv.port, port) &&
14173 SameDomainLabel(ThirdLabel(r2->resrec.name)->c, tp))
14174 break;
14175 if (!r2 && mDNSSameIPPort(port, IPSECPort)) r2 = rr; // So that we wake for BTMM IPSEC packets, even without a matching SRV record
14176 if (!r2 && kaWake) r2 = rr; // So that we wake for keepalive packets, even without a matching SRV record
14177 if (r2)
14178 {
14179 LogMsg("Waking host at %s %#a H-MAC %.6a I-MAC %.6a for %s",
14180 InterfaceNameForID(m, rr->resrec.InterfaceID), dst, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, r2));
14181 ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC);
14182 }
14183 else
14184 LogSPS("Sleeping host at %s %#a %.6a has no service on %#s %d",
14185 InterfaceNameForID(m, rr->resrec.InterfaceID), dst, &rr->WakeUp.HMAC, tp, mDNSVal16(port));
14186 }
14187 mDNS_Unlock(m);
14188 }
14189}
14190
14191mDNSexport void mDNSCoreReceiveRawPacket(mDNS *const m, const mDNSu8 *const p, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID)
14192{
14193 static const mDNSOpaque16 Ethertype_ARP = { { 0x08, 0x06 } }; // Ethertype 0x0806 = ARP
14194 static const mDNSOpaque16 Ethertype_IPv4 = { { 0x08, 0x00 } }; // Ethertype 0x0800 = IPv4
14195 static const mDNSOpaque16 Ethertype_IPv6 = { { 0x86, 0xDD } }; // Ethertype 0x86DD = IPv6
14196 static const mDNSOpaque16 ARP_hrd_eth = { { 0x00, 0x01 } }; // Hardware address space (Ethernet = 1)
14197 static const mDNSOpaque16 ARP_pro_ip = { { 0x08, 0x00 } }; // Protocol address space (IP = 0x0800)
14198
14199 // Note: BPF guarantees that the NETWORK LAYER header will be word aligned, not the link-layer header.
14200 // In other words, we can safely assume that pkt below (ARP, IPv4 or IPv6) is properly word aligned,
14201 // but if pkt is 4-byte aligned, that necessarily means that eth CANNOT also be 4-byte aligned
14202 // since it points to a an address 14 bytes before pkt.
14203 const EthernetHeader *const eth = (const EthernetHeader *)p;
14204 const NetworkLayerPacket *const pkt = (const NetworkLayerPacket *)(eth+1);
14205 mDNSAddr src, dst;
14206 #define RequiredCapLen(P) ((P)==0x01 ? 4 : (P)==0x06 ? 20 : (P)==0x11 ? 8 : (P)==0x3A ? 24 : 0)
14207
14208 // Is ARP? Length must be at least 14 + 28 = 42 bytes
14209 if (end >= p+42 && mDNSSameOpaque16(eth->ethertype, Ethertype_ARP) && mDNSSameOpaque16(pkt->arp.hrd, ARP_hrd_eth) && mDNSSameOpaque16(pkt->arp.pro, ARP_pro_ip))
14210 mDNSCoreReceiveRawARP(m, &pkt->arp, InterfaceID);
14211 // Is IPv4 with zero fragmentation offset? Length must be at least 14 + 20 = 34 bytes
14212 else if (end >= p+34 && mDNSSameOpaque16(eth->ethertype, Ethertype_IPv4) && (pkt->v4.flagsfrags.b[0] & 0x1F) == 0 && pkt->v4.flagsfrags.b[1] == 0)
14213 {
14214 const mDNSu8 *const trans = p + 14 + (pkt->v4.vlen & 0xF) * 4;
14215 const mDNSu8 * transEnd = p + 14 + mDNSVal16(pkt->v4.totlen);
14216 if (transEnd > end) transEnd = end;
14217 debugf("Got IPv4 %02X from %.4a to %.4a", pkt->v4.protocol, &pkt->v4.src, &pkt->v4.dst);
14218 src.type = mDNSAddrType_IPv4; src.ip.v4 = pkt->v4.src;
14219 dst.type = mDNSAddrType_IPv4; dst.ip.v4 = pkt->v4.dst;
14220 if (transEnd >= trans + RequiredCapLen(pkt->v4.protocol))
14221 mDNSCoreReceiveRawTransportPacket(m, &eth->src, &src, &dst, pkt->v4.protocol, p, (TransportLayerPacket*)trans, transEnd, InterfaceID, 0);
14222 }
14223 // Is IPv6? Length must be at least 14 + 28 = 42 bytes
14224 else if (end >= p+54 && mDNSSameOpaque16(eth->ethertype, Ethertype_IPv6))
14225 {
14226 const mDNSu8 *const trans = p + 54;
14227 debugf("Got IPv6 %02X from %.16a to %.16a", pkt->v6.pro, &pkt->v6.src, &pkt->v6.dst);
14228 src.type = mDNSAddrType_IPv6; src.ip.v6 = pkt->v6.src;
14229 dst.type = mDNSAddrType_IPv6; dst.ip.v6 = pkt->v6.dst;
14230 if (end >= trans + RequiredCapLen(pkt->v6.pro))
14231 mDNSCoreReceiveRawTransportPacket(m, &eth->src, &src, &dst, pkt->v6.pro, p, (TransportLayerPacket*)trans, end, InterfaceID,
14232 (mDNSu16)pkt->bytes[4] << 8 | pkt->bytes[5]);
14233 }
14234}
14235
14236mDNSlocal void ConstructSleepProxyServerName(mDNS *const m, domainlabel *name)
14237{
14238 name->c[0] = (mDNSu8)mDNS_snprintf((char*)name->c+1, 62, "%d-%d-%d-%d.%d %#s",
14239 m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower, m->SPSFeatureFlags, &m->nicelabel);
14240}
14241
14242#ifndef SPC_DISABLED
14243mDNSlocal void SleepProxyServerCallback(mDNS *const m, ServiceRecordSet *const srs, mStatus result)
14244{
14245 if (result == mStatus_NameConflict)
14246 mDNS_RenameAndReregisterService(m, srs, mDNSNULL);
14247 else if (result == mStatus_MemFree)
14248 {
14249 if (m->SleepState)
14250 m->SPSState = 3;
14251 else
14252 {
14253 m->SPSState = (mDNSu8)(m->SPSSocket != mDNSNULL);
14254 if (m->SPSState)
14255 {
14256 domainlabel name;
14257 ConstructSleepProxyServerName(m, &name);
14258 mDNS_RegisterService(m, srs,
14259 &name, &SleepProxyServiceType, &localdomain,
14260 mDNSNULL, m->SPSSocket->port, // Host, port
14261 (mDNSu8 *)"", 1, // TXT data, length
14262 mDNSNULL, 0, // Subtypes (none)
14263 mDNSInterface_Any, // Interface ID
14264 SleepProxyServerCallback, mDNSNULL, 0); // Callback, context, flags
14265 }
14266 LogSPS("Sleep Proxy Server %#s %s", srs->RR_SRV.resrec.name->c, m->SPSState ? "started" : "stopped");
14267 }
14268 }
14269}
14270#endif
14271
14272// Called with lock held
14273mDNSexport void mDNSCoreBeSleepProxyServer_internal(mDNS *const m, mDNSu8 sps, mDNSu8 port, mDNSu8 marginalpower, mDNSu8 totpower, mDNSu8 features)
14274{
14275 // This routine uses mDNS_DeregisterService and calls SleepProxyServerCallback, so we execute in user callback context
14276 mDNS_DropLockBeforeCallback();
14277
14278 // If turning off SPS, close our socket
14279 // (Do this first, BEFORE calling mDNS_DeregisterService below)
14280 if (!sps && m->SPSSocket) { mDNSPlatformUDPClose(m->SPSSocket); m->SPSSocket = mDNSNULL; }
14281
14282 // If turning off, or changing type, deregister old name
14283#ifndef SPC_DISABLED
14284 if (m->SPSState == 1 && sps != m->SPSType)
14285 { m->SPSState = 2; mDNS_DeregisterService_drt(m, &m->SPSRecords, sps ? mDNS_Dereg_rapid : mDNS_Dereg_normal); }
14286#endif // SPC_DISABLED
14287
14288 // Record our new SPS parameters
14289 m->SPSType = sps;
14290 m->SPSPortability = port;
14291 m->SPSMarginalPower = marginalpower;
14292 m->SPSTotalPower = totpower;
14293 m->SPSFeatureFlags = features;
14294 // If turning on, open socket and advertise service
14295 if (sps)
14296 {
14297 if (!m->SPSSocket)
14298 {
14299 m->SPSSocket = mDNSPlatformUDPSocket(zeroIPPort);
14300 if (!m->SPSSocket) { LogMsg("mDNSCoreBeSleepProxyServer: Failed to allocate SPSSocket"); goto fail; }
14301 }
14302#ifndef SPC_DISABLED
14303 if (m->SPSState == 0) SleepProxyServerCallback(m, &m->SPSRecords, mStatus_MemFree);
14304#endif // SPC_DISABLED
14305 }
14306 else if (m->SPSState)
14307 {
14308 LogSPS("mDNSCoreBeSleepProxyServer turning off from state %d; will wake clients", m->SPSState);
14309 m->NextScheduledSPS = m->timenow;
14310 }
14311fail:
14312 mDNS_ReclaimLockAfterCallback();
14313}
14314
14315// ***************************************************************************
14316#if COMPILER_LIKES_PRAGMA_MARK
14317#pragma mark -
14318#pragma mark - Startup and Shutdown
14319#endif
14320
14321mDNSlocal void mDNS_GrowCache_internal(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords)
14322{
14323 if (storage && numrecords)
14324 {
14325 mDNSu32 i;
14326 debugf("Adding cache storage for %d more records (%d bytes)", numrecords, numrecords*sizeof(CacheEntity));
14327 for (i=0; i<numrecords; i++) storage[i].next = &storage[i+1];
14328 storage[numrecords-1].next = m->rrcache_free;
14329 m->rrcache_free = storage;
14330 m->rrcache_size += numrecords;
14331 }
14332}
14333
14334mDNSexport void mDNS_GrowCache(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords)
14335{
14336 mDNS_Lock(m);
14337 mDNS_GrowCache_internal(m, storage, numrecords);
14338 mDNS_Unlock(m);
14339}
14340
14341mDNSlocal mStatus mDNS_InitStorage(mDNS *const m, mDNS_PlatformSupport *const p,
14342 CacheEntity *rrcachestorage, mDNSu32 rrcachesize,
14343 mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context)
14344{
14345 mDNSu32 slot;
14346 mDNSs32 timenow;
14347 mStatus result;
14348
14349 if (!rrcachestorage) rrcachesize = 0;
14350
14351 m->p = p;
14352 m->NetworkChanged = 0;
14353 m->CanReceiveUnicastOn5353 = mDNSfalse; // Assume we can't receive unicasts on 5353, unless platform layer tells us otherwise
14354 m->AdvertiseLocalAddresses = AdvertiseLocalAddresses;
14355 m->DivertMulticastAdvertisements = mDNSfalse;
14356 m->mDNSPlatformStatus = mStatus_Waiting;
14357 m->UnicastPort4 = zeroIPPort;
14358 m->UnicastPort6 = zeroIPPort;
14359 m->PrimaryMAC = zeroEthAddr;
14360 m->MainCallback = Callback;
14361 m->MainContext = Context;
14362 m->rec.r.resrec.RecordType = 0;
14363 m->rec.r.resrec.AnonInfo = mDNSNULL;
14364
14365 // For debugging: To catch and report locking failures
14366 m->mDNS_busy = 0;
14367 m->mDNS_reentrancy = 0;
14368 m->ShutdownTime = 0;
14369 m->lock_rrcache = 0;
14370 m->lock_Questions = 0;
14371 m->lock_Records = 0;
14372
14373 // Task Scheduling variables
14374 result = mDNSPlatformTimeInit();
14375 if (result != mStatus_NoError) return(result);
14376 m->timenow_adjust = (mDNSs32)mDNSRandom(0xFFFFFFFF);
14377 timenow = mDNS_TimeNow_NoLock(m);
14378
14379 m->timenow = 0; // MUST only be set within mDNS_Lock/mDNS_Unlock section
14380 m->timenow_last = timenow;
14381 m->NextScheduledEvent = timenow;
14382 m->SuppressSending = timenow;
14383 m->NextCacheCheck = timenow + FutureTime;
14384 m->NextScheduledQuery = timenow + FutureTime;
14385 m->NextScheduledProbe = timenow + FutureTime;
14386 m->NextScheduledResponse = timenow + FutureTime;
14387 m->NextScheduledNATOp = timenow + FutureTime;
14388 m->NextScheduledSPS = timenow + FutureTime;
14389 m->NextScheduledKA = timenow + FutureTime;
14390 m->NextScheduledStopTime = timenow + FutureTime;
14391 m->NextBLEServiceTime = 0; // zero indicates inactive
14392
14393#if BONJOUR_ON_DEMAND
14394 m->NextBonjourDisableTime = 0; // Timer active when non zero.
14395 m->BonjourEnabled = 0; // Set when Bonjour on Demand is enabled and Bonjour is currently enabled.
14396#endif // BONJOUR_ON_DEMAND
14397
14398 m->DelayConflictProcessing = MAX_CONFLICT_PROCESSING_DELAYS;
14399 m->RandomQueryDelay = 0;
14400 m->RandomReconfirmDelay = 0;
14401 m->PktNum = 0;
14402 m->MPktNum = 0;
14403 m->LocalRemoveEvents = mDNSfalse;
14404 m->SleepState = SleepState_Awake;
14405 m->SleepSeqNum = 0;
14406 m->SystemWakeOnLANEnabled = mDNSfalse;
14407 m->AnnounceOwner = NonZeroTime(timenow + 60 * mDNSPlatformOneSecond);
14408 m->DelaySleep = 0;
14409 m->SleepLimit = 0;
14410
14411#if APPLE_OSX_mDNSResponder
14412 m->UnicastPacketsSent = 0;
14413 m->MulticastPacketsSent = 0;
14414 m->RemoteSubnet = 0;
14415#endif // APPLE_OSX_mDNSResponder
14416
14417 // These fields only required for mDNS Searcher...
14418 m->Questions = mDNSNULL;
14419 m->NewQuestions = mDNSNULL;
14420 m->CurrentQuestion = mDNSNULL;
14421 m->LocalOnlyQuestions = mDNSNULL;
14422 m->NewLocalOnlyQuestions = mDNSNULL;
14423 m->RestartQuestion = mDNSNULL;
14424 m->ValidationQuestion = mDNSNULL;
14425 m->rrcache_size = 0;
14426 m->rrcache_totalused = 0;
14427 m->rrcache_active = 0;
14428 m->rrcache_report = 10;
14429 m->rrcache_free = mDNSNULL;
14430
14431 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
14432 {
14433 m->rrcache_hash[slot] = mDNSNULL;
14434 m->rrcache_nextcheck[slot] = timenow + FutureTime;;
14435 }
14436
14437 mDNS_GrowCache_internal(m, rrcachestorage, rrcachesize);
14438 m->rrauth.rrauth_free = mDNSNULL;
14439
14440 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
14441 m->rrauth.rrauth_hash[slot] = mDNSNULL;
14442
14443 // Fields below only required for mDNS Responder...
14444 m->hostlabel.c[0] = 0;
14445 m->nicelabel.c[0] = 0;
14446 m->MulticastHostname.c[0] = 0;
14447 m->HIHardware.c[0] = 0;
14448 m->HISoftware.c[0] = 0;
14449 m->ResourceRecords = mDNSNULL;
14450 m->DuplicateRecords = mDNSNULL;
14451 m->NewLocalRecords = mDNSNULL;
14452 m->NewLocalOnlyRecords = mDNSfalse;
14453 m->CurrentRecord = mDNSNULL;
14454 m->HostInterfaces = mDNSNULL;
14455 m->ProbeFailTime = 0;
14456 m->NumFailedProbes = 0;
14457 m->SuppressProbes = 0;
14458
14459#ifndef UNICAST_DISABLED
14460 m->NextuDNSEvent = timenow + FutureTime;
14461 m->NextSRVUpdate = timenow + FutureTime;
14462
14463 m->DNSServers = mDNSNULL;
14464
14465 m->Router = zeroAddr;
14466 m->AdvertisedV4 = zeroAddr;
14467 m->AdvertisedV6 = zeroAddr;
14468
14469 m->AuthInfoList = mDNSNULL;
14470
14471 m->ReverseMap.ThisQInterval = -1;
14472 m->StaticHostname.c[0] = 0;
14473 m->FQDN.c[0] = 0;
14474 m->Hostnames = mDNSNULL;
14475 m->AutoTunnelNAT.clientContext = mDNSNULL;
14476
14477 m->WABBrowseQueriesCount = 0;
14478 m->WABLBrowseQueriesCount = 0;
14479 m->WABRegQueriesCount = 0;
14480 m->AutoTargetServices = 1;
14481
14482#if BONJOUR_ON_DEMAND
14483 m->NumAllInterfaceRecords = 0;
14484 m->NumAllInterfaceQuestions = 0;
14485#endif
14486 // NAT traversal fields
14487 m->LLQNAT.clientCallback = mDNSNULL;
14488 m->LLQNAT.clientContext = mDNSNULL;
14489 m->NATTraversals = mDNSNULL;
14490 m->CurrentNATTraversal = mDNSNULL;
14491 m->retryIntervalGetAddr = 0; // delta between time sent and retry
14492 m->retryGetAddr = timenow + FutureTime; // absolute time when we retry
14493 m->ExtAddress = zerov4Addr;
14494 m->PCPNonce[0] = mDNSRandom(-1);
14495 m->PCPNonce[1] = mDNSRandom(-1);
14496 m->PCPNonce[2] = mDNSRandom(-1);
14497
14498 m->NATMcastRecvskt = mDNSNULL;
14499 m->LastNATupseconds = 0;
14500 m->LastNATReplyLocalTime = timenow;
14501 m->LastNATMapResultCode = NATErr_None;
14502
14503 m->UPnPInterfaceID = 0;
14504 m->SSDPSocket = mDNSNULL;
14505 m->SSDPWANPPPConnection = mDNSfalse;
14506 m->UPnPRouterPort = zeroIPPort;
14507 m->UPnPSOAPPort = zeroIPPort;
14508 m->UPnPRouterURL = mDNSNULL;
14509 m->UPnPWANPPPConnection = mDNSfalse;
14510 m->UPnPSOAPURL = mDNSNULL;
14511 m->UPnPRouterAddressString = mDNSNULL;
14512 m->UPnPSOAPAddressString = mDNSNULL;
14513 m->SPSType = 0;
14514 m->SPSPortability = 0;
14515 m->SPSMarginalPower = 0;
14516 m->SPSTotalPower = 0;
14517 m->SPSFeatureFlags = 0;
14518 m->SPSState = 0;
14519 m->SPSProxyListChanged = mDNSNULL;
14520 m->SPSSocket = mDNSNULL;
14521 m->SPSBrowseCallback = mDNSNULL;
14522 m->ProxyRecords = 0;
14523
14524 m->DNSPushServers = mDNSNULL;
14525 m->DNSPushZones = mDNSNULL;
14526#endif
14527
14528#if APPLE_OSX_mDNSResponder
14529 m->TunnelClients = mDNSNULL;
14530
14531#if !NO_WCF
14532 CHECK_WCF_FUNCTION(WCFConnectionNew)
14533 {
14534 m->WCF = WCFConnectionNew();
14535 if (!m->WCF) { LogMsg("WCFConnectionNew failed"); return -1; }
14536 }
14537#endif
14538
14539#endif
14540
14541 return(result);
14542}
14543
14544mDNSexport mStatus mDNS_Init(mDNS *const m, mDNS_PlatformSupport *const p,
14545 CacheEntity *rrcachestorage, mDNSu32 rrcachesize,
14546 mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context)
14547{
14548 mStatus result = mDNS_InitStorage(m, p, rrcachestorage, rrcachesize, AdvertiseLocalAddresses, Callback, Context);
14549 if (result != mStatus_NoError)
14550 return(result);
14551
14552 result = mDNSPlatformInit(m);
14553
14554#ifndef UNICAST_DISABLED
14555 // It's better to do this *after* the platform layer has set up the
14556 // interface list and security credentials
14557 uDNS_SetupDNSConfig(m); // Get initial DNS configuration
14558#endif
14559
14560 return(result);
14561}
14562
14563mDNSexport void mDNS_ConfigChanged(mDNS *const m)
14564{
14565 if (m->SPSState == 1)
14566 {
14567 domainlabel name, newname;
14568#ifndef SPC_DISABLED
14569 domainname type, domain;
14570 DeconstructServiceName(m->SPSRecords.RR_SRV.resrec.name, &name, &type, &domain);
14571#endif // SPC_DISABLED
14572 ConstructSleepProxyServerName(m, &newname);
14573 if (!SameDomainLabelCS(name.c, newname.c))
14574 {
14575 LogSPS("Renaming SPS from “%#s” to “%#s”", name.c, newname.c);
14576 // When SleepProxyServerCallback gets the mStatus_MemFree message,
14577 // it will reregister the service under the new name
14578 m->SPSState = 2;
14579#ifndef SPC_DISABLED
14580 mDNS_DeregisterService_drt(m, &m->SPSRecords, mDNS_Dereg_rapid);
14581#endif // SPC_DISABLED
14582 }
14583 }
14584
14585 if (m->MainCallback)
14586 m->MainCallback(m, mStatus_ConfigChanged);
14587}
14588
14589mDNSlocal void DynDNSHostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
14590{
14591 (void)m; // unused
14592 debugf("NameStatusCallback: result %d for registration of name %##s", result, rr->resrec.name->c);
14593 mDNSPlatformDynDNSHostNameStatusChanged(rr->resrec.name, result);
14594}
14595
14596mDNSlocal void PurgeOrReconfirmCacheRecord(mDNS *const m, CacheRecord *cr, const DNSServer * const ptr, mDNSBool lameduck)
14597{
14598 mDNSBool purge = cr->resrec.RecordType == kDNSRecordTypePacketNegative ||
14599 cr->resrec.rrtype == kDNSType_A ||
14600 cr->resrec.rrtype == kDNSType_AAAA ||
14601 cr->resrec.rrtype == kDNSType_SRV ||
14602 cr->resrec.rrtype == kDNSType_CNAME;
14603
14604 (void) lameduck;
14605 (void) ptr;
14606 debugf("PurgeOrReconfirmCacheRecord: %s cache record due to %s server %p %#a:%d (%##s): %s",
14607 purge ? "purging" : "reconfirming",
14608 lameduck ? "lame duck" : "new",
14609 ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c, CRDisplayString(m, cr));
14610
14611 if (purge)
14612 {
14613 LogInfo("PurgeorReconfirmCacheRecord: Purging Resourcerecord %s, RecordType %x", CRDisplayString(m, cr), cr->resrec.RecordType);
14614 mDNS_PurgeCacheResourceRecord(m, cr);
14615 }
14616 else
14617 {
14618 LogInfo("PurgeorReconfirmCacheRecord: Reconfirming Resourcerecord %s, RecordType %x", CRDisplayString(m, cr), cr->resrec.RecordType);
14619 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
14620 }
14621}
14622
14623mDNSlocal void mDNS_PurgeForQuestion(mDNS *const m, DNSQuestion *q)
14624{
14625 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
14626 CacheRecord *rp;
14627 mDNSu8 validatingResponse = 0;
14628
14629 // For DNSSEC questions, purge the corresponding RRSIGs also.
14630 if (DNSSECQuestion(q))
14631 {
14632 validatingResponse = q->ValidatingResponse;
14633 q->ValidatingResponse = mDNStrue;
14634 }
14635 for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next)
14636 {
14637 if (SameNameRecordAnswersQuestion(&rp->resrec, q))
14638 {
14639 LogInfo("mDNS_PurgeForQuestion: Flushing %s", CRDisplayString(m, rp));
14640 mDNS_PurgeCacheResourceRecord(m, rp);
14641 }
14642 }
14643 if (DNSSECQuestion(q))
14644 {
14645 q->ValidatingResponse = validatingResponse;
14646 }
14647}
14648
14649// For DNSSEC question, we need the DNSSEC records also. If the cache does not
14650// have the DNSSEC records, we need to re-issue the question with EDNS0/DO bit set.
14651// Just re-issuing the question for RRSIGs does not work in practice as the response
14652// may not contain the RRSIGs whose typeCovered field matches the question's qtype.
14653//
14654// For negative responses, we need the NSECs to prove the non-existence. If we don't
14655// have the cached NSECs, purge them. For positive responses, if we don't have the
14656// RRSIGs and if we have not already issued the question with EDNS0/DO bit set, purge
14657// them.
14658mDNSlocal void CheckForDNSSECRecords(mDNS *const m, DNSQuestion *q)
14659{
14660 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
14661 CacheRecord *rp;
14662
14663 for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next)
14664 {
14665 if (SameNameRecordAnswersQuestion(&rp->resrec, q))
14666 {
14667 if (rp->resrec.RecordType != kDNSRecordTypePacketNegative || !rp->nsec)
14668 {
14669 if (!rp->CRDNSSECQuestion)
14670 {
14671 LogInfo("CheckForDNSSECRecords: Flushing %s", CRDisplayString(m, rp));
14672 mDNS_PurgeCacheResourceRecord(m, rp);
14673 }
14674 }
14675 }
14676 }
14677}
14678
14679// Check for a positive unicast response to the question but with qtype
14680mDNSexport mDNSBool mDNS_CheckForCacheRecord(mDNS *const m, DNSQuestion *q, mDNSu16 qtype)
14681{
14682 DNSQuestion question;
14683 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname);
14684 CacheRecord *rp;
14685
14686 // Create an identical question but with qtype
14687 mDNS_SetupQuestion(&question, q->InterfaceID, &q->qname, qtype, mDNSNULL, mDNSNULL);
14688 question.qDNSServer = q->qDNSServer;
14689
14690 for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next)
14691 {
14692 if (!rp->resrec.InterfaceID && rp->resrec.RecordType != kDNSRecordTypePacketNegative &&
14693 SameNameRecordAnswersQuestion(&rp->resrec, &question))
14694 {
14695 LogInfo("mDNS_CheckForCacheRecord: Found %s", CRDisplayString(m, rp));
14696 return mDNStrue;
14697 }
14698 }
14699 return mDNSfalse;
14700}
14701
14702mDNSexport void DNSServerChangeForQuestion(mDNS *const m, DNSQuestion *q, DNSServer *new)
14703{
14704 DNSQuestion *qptr;
14705
14706 (void) m;
14707
14708 if (q->DuplicateOf)
14709 LogMsg("DNSServerChangeForQuestion: ERROR: Called for duplicate question %##s", q->qname.c);
14710
14711 // Make sure all the duplicate questions point to the same DNSServer so that delivery
14712 // of events for all of them are consistent. Duplicates for a question are always inserted
14713 // after in the list.
14714 q->qDNSServer = new;
14715 for (qptr = q->next ; qptr; qptr = qptr->next)
14716 {
14717 if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = new; }
14718 }
14719}
14720
14721mDNSlocal void SetConfigState(mDNS *const m, mDNSBool delete)
14722{
14723 McastResolver *mr;
14724 DNSServer *ptr;
14725
14726 if (delete)
14727 {
14728 for (ptr = m->DNSServers; ptr; ptr = ptr->next)
14729 {
14730 ptr->penaltyTime = 0;
14731 NumUnicastDNSServers--;
14732 ptr->flags |= DNSServer_FlagDelete;
14733#if APPLE_OSX_mDNSResponder
14734 if (ptr->flags & DNSServer_FlagUnreachable)
14735 NumUnreachableDNSServers--;
14736#endif
14737 }
14738 // We handle the mcast resolvers here itself as mDNSPlatformSetDNSConfig looks at
14739 // mcast resolvers. Today we get both mcast and ucast configuration using the same
14740 // API
14741 for (mr = m->McastResolvers; mr; mr = mr->next)
14742 mr->flags |= McastResolver_FlagDelete;
14743 }
14744 else
14745 {
14746 for (ptr = m->DNSServers; ptr; ptr = ptr->next)
14747 {
14748 ptr->penaltyTime = 0;
14749 NumUnicastDNSServers++;
14750 ptr->flags &= ~DNSServer_FlagDelete;
14751#if APPLE_OSX_mDNSResponder
14752 if (ptr->flags & DNSServer_FlagUnreachable)
14753 NumUnreachableDNSServers++;
14754#endif
14755 }
14756 for (mr = m->McastResolvers; mr; mr = mr->next)
14757 mr->flags &= ~McastResolver_FlagDelete;
14758 }
14759}
14760
14761mDNSlocal void SetDynDNSHostNameIfChanged(mDNS *const m, domainname *const fqdn)
14762{
14763 // Did our FQDN change?
14764 if (!SameDomainName(fqdn, &m->FQDN))
14765 {
14766 if (m->FQDN.c[0]) mDNS_RemoveDynDNSHostName(m, &m->FQDN);
14767
14768 AssignDomainName(&m->FQDN, fqdn);
14769
14770 if (m->FQDN.c[0])
14771 {
14772 mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1);
14773 mDNS_AddDynDNSHostName(m, &m->FQDN, DynDNSHostNameCallback, mDNSNULL);
14774 }
14775 }
14776}
14777
14778mDNSexport mStatus uDNS_SetupDNSConfig(mDNS *const m)
14779{
14780 mDNSu32 slot;
14781 CacheGroup *cg;
14782 CacheRecord *cr;
14783 mDNSBool Restart = mDNSfalse;
14784 mDNSAddr v4, v6, r;
14785 domainname fqdn;
14786 DNSServer *ptr, **p = &m->DNSServers;
14787 const DNSServer *oldServers = m->DNSServers;
14788 DNSQuestion *q;
14789 McastResolver *mr, **mres = &m->McastResolvers;
14790
14791 debugf("uDNS_SetupDNSConfig: entry");
14792
14793 // Let the platform layer get the current DNS information and setup the WAB queries if needed.
14794 uDNS_SetupWABQueries(m);
14795
14796 mDNS_Lock(m);
14797
14798 // We need to first mark all the entries to be deleted. If the configuration changed, then
14799 // the entries would be undeleted appropriately. Otherwise, we need to clear them.
14800 //
14801 // Note: The last argument to mDNSPlatformSetDNSConfig is "mDNStrue" which means ack the
14802 // configuration. We already processed search domains in uDNS_SetupWABQueries above and
14803 // hence we are ready to ack the configuration as this is the last call to mDNSPlatformSetConfig
14804 // for the dns configuration change notification.
14805 SetConfigState(m, mDNStrue);
14806 if (!mDNSPlatformSetDNSConfig(mDNStrue, mDNSfalse, &fqdn, mDNSNULL, mDNSNULL, mDNStrue))
14807 {
14808 SetDynDNSHostNameIfChanged(m, &fqdn);
14809 SetConfigState(m, mDNSfalse);
14810 mDNS_Unlock(m);
14811 LogInfo("uDNS_SetupDNSConfig: No configuration change");
14812 return mStatus_NoError;
14813 }
14814
14815 // For now, we just delete the mcast resolvers. We don't deal with cache or
14816 // questions here. Neither question nor cache point to mcast resolvers. Questions
14817 // do inherit the timeout values from mcast resolvers. But we don't bother
14818 // affecting them as they never change.
14819 while (*mres)
14820 {
14821 if (((*mres)->flags & McastResolver_FlagDelete) != 0)
14822 {
14823 mr = *mres;
14824 *mres = (*mres)->next;
14825 debugf("uDNS_SetupDNSConfig: Deleting mcast resolver %##s", mr, mr->domain.c);
14826 mDNSPlatformMemFree(mr);
14827 }
14828 else
14829 {
14830 (*mres)->flags &= ~McastResolver_FlagNew;
14831 mres = &(*mres)->next;
14832 }
14833 }
14834
14835 // Update our qDNSServer pointers before we go and free the DNSServer object memory
14836 //
14837 // All non-scoped resolvers share the same resGroupID. At no point in time a cache entry using DNSServer
14838 // from scoped resolver will be used to answer non-scoped questions and vice versa, as scoped and non-scoped
14839 // resolvers don't share the same resGroupID. A few examples to describe the interaction with how we pick
14840 // DNSServers and flush the cache.
14841 //
14842 // - A non-scoped question picks DNSServer X, creates a cache entry with X. If a new resolver gets added later that
14843 // is a better match, we pick the new DNSServer for the question and activate the unicast query. We may or may not
14844 // flush the cache (See PurgeOrReconfirmCacheRecord). In either case, we don't change the cache record's DNSServer
14845 // pointer immediately (qDNSServer and rDNSServer may be different but still share the same resGroupID). If we don't
14846 // flush the cache immediately, the record's rDNSServer pointer will be updated (in mDNSCoreReceiveResponse)
14847 // later when we get the response. If we purge the cache, we still deliver a RMV when it is purged even though
14848 // we don't update the cache record's DNSServer pointer to match the question's DNSSever, as they both point to
14849 // the same resGroupID.
14850 //
14851 // Note: If the new DNSServer comes back with a different response than what we have in the cache, we will deliver a RMV
14852 // of the old followed by ADD of the new records.
14853 //
14854 // - A non-scoped question picks DNSServer X, creates a cache entry with X. If the resolver gets removed later, we will
14855 // pick a new DNSServer for the question which may or may not be NULL and set the cache record's pointer to the same
14856 // as in question's qDNSServer if the cache record is not flushed. If there is no active question, it will be set to NULL.
14857 //
14858 // - Two questions scoped and non-scoped for the same name will pick two different DNSServer and will end up creating separate
14859 // cache records and as the resGroupID is different, you can't use the cache record from the scoped DNSServer to answer the
14860 // non-scoped question and vice versa.
14861 //
14862#if USE_DNS64
14863 DNS64RestartQuestions(m);
14864#endif
14865 for (q = m->Questions; q; q=q->next)
14866 {
14867 if (!mDNSOpaque16IsZero(q->TargetQID))
14868 {
14869 DNSServer *s, *t;
14870 DNSQuestion *qptr;
14871 if (q->DuplicateOf) continue;
14872 SetValidDNSServers(m, q);
14873 q->triedAllServersOnce = 0;
14874 s = GetServerForQuestion(m, q);
14875 t = q->qDNSServer;
14876 if (t != s)
14877 {
14878 mDNSBool old, new;
14879 // If DNS Server for this question has changed, reactivate it
14880 LogInfo("uDNS_SetupDNSConfig: Updating DNS Server from %#a:%d (%##s) to %#a:%d (%##s) for question %##s (%s) (scope:%p)",
14881 t ? &t->addr : mDNSNULL, mDNSVal16(t ? t->port : zeroIPPort), t ? t->domain.c : (mDNSu8*)"",
14882 s ? &s->addr : mDNSNULL, mDNSVal16(s ? s->port : zeroIPPort), s ? s->domain.c : (mDNSu8*)"",
14883 q->qname.c, DNSTypeName(q->qtype), q->InterfaceID);
14884
14885 old = q->SuppressQuery;
14886 new = ShouldSuppressUnicastQuery(m, q, s);
14887 if (old != new)
14888 {
14889 // Changing the DNS server affected the SuppressQuery status. We need to
14890 // deliver RMVs for the previous ADDs (if any) before switching to the new
14891 // DNSServer. To keep it simple, we walk all the questions and mark them
14892 // to be restarted and then handle all of them at once.
14893 q->Restart = 1;
14894 q->SuppressQuery = new;
14895 for (qptr = q->next ; qptr; qptr = qptr->next)
14896 {
14897 if (qptr->DuplicateOf == q)
14898 qptr->Restart = 1;
14899 }
14900 Restart = mDNStrue;
14901 }
14902 else
14903 {
14904 DNSServerChangeForQuestion(m, q, s);
14905 q->unansweredQueries = 0;
14906
14907 // If we had sent a query out to DNSServer "t" and we are changing to "s", we
14908 // need to ignore the responses coming back from "t" as the DNS configuration
14909 // has changed e.g., when a new interface is coming up and that becomes the primary
14910 // interface, we switch to the DNS servers configured for the primary interface. In
14911 // this case, we should not accept responses associated with the previous interface as
14912 // the "name" could resolve differently on this new primary interface. Hence, discard
14913 // in-flight responses.
14914 q->TargetQID = mDNS_NewMessageID(m);
14915
14916 if (!QuerySuppressed(q))
14917 {
14918 debugf("uDNS_SetupDNSConfig: Activating query %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
14919 ActivateUnicastQuery(m, q, mDNStrue);
14920 // ActivateUnicastQuery is called for duplicate questions also as it does something
14921 // special for AutoTunnel questions
14922 for (qptr = q->next ; qptr; qptr = qptr->next)
14923 {
14924 if (qptr->DuplicateOf == q) ActivateUnicastQuery(m, qptr, mDNStrue);
14925 }
14926 }
14927 }
14928 }
14929 else
14930 {
14931 debugf("uDNS_SetupDNSConfig: Not Updating DNS server question %p %##s (%s) DNS server %#a:%d %p %d",
14932 q, q->qname.c, DNSTypeName(q->qtype), t ? &t->addr : mDNSNULL, mDNSVal16(t ? t->port : zeroIPPort), q->DuplicateOf, q->SuppressUnusable);
14933 for (qptr = q->next ; qptr; qptr = qptr->next)
14934 if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = q->qDNSServer; }
14935 }
14936 }
14937 }
14938 if (Restart)
14939 RestartUnicastQuestions(m);
14940
14941 FORALL_CACHERECORDS(slot, cg, cr)
14942 {
14943 if (cr->resrec.InterfaceID)
14944 continue;
14945
14946 // We already walked the questions and restarted/reactivated them if the dns server
14947 // change affected the question. That should take care of updating the cache. But
14948 // what if there is no active question at this point when the DNS server change
14949 // happened ? There could be old cache entries lying around and if we don't flush
14950 // them, a new question after the DNS server change could pick up these stale
14951 // entries and get a wrong answer.
14952 //
14953 // For cache entries that have active questions we might have skipped rescheduling
14954 // the questions if they were suppressed (see above). To keep it simple, we walk
14955 // all the cache entries to make sure that there are no stale entries. We use the
14956 // active question's InterfaceID/ServiceID for looking up the right DNS server.
14957 // Note that the unscoped value for ServiceID is -1.
14958 //
14959 // Note: If GetServerForName returns NULL, it could either mean that there are no
14960 // DNS servers or no matching DNS servers for this question. In either case,
14961 // the cache should get purged below when we process deleted DNS servers.
14962
14963 ptr = GetServerForName(m, cr->resrec.name,
14964 (cr->CRActiveQuestion ? cr->CRActiveQuestion->InterfaceID : mDNSNULL),
14965 (cr->CRActiveQuestion ? cr->CRActiveQuestion->ServiceID : -1));
14966
14967 // Purge or Reconfirm if this cache entry would use the new DNS server
14968 if (ptr && (ptr != cr->resrec.rDNSServer))
14969 {
14970 // As the DNSServers for this cache record is not the same anymore, we don't
14971 // want any new questions to pick this old value. If there is no active question,
14972 // we can't possibly re-confirm, so purge in that case. If it is a DNSSEC question,
14973 // purge the cache as the DNSSEC capabilities of the DNS server may have changed.
14974
14975 if (cr->CRActiveQuestion == mDNSNULL || DNSSECQuestion(cr->CRActiveQuestion))
14976 {
14977 LogInfo("uDNS_SetupDNSConfig: Purging Resourcerecord %s, New DNS server %#a , Old DNS server %#a", CRDisplayString(m, cr),
14978 &ptr->addr, (cr->resrec.rDNSServer != mDNSNULL ? &cr->resrec.rDNSServer->addr : mDNSNULL));
14979 mDNS_PurgeCacheResourceRecord(m, cr);
14980 }
14981 else
14982 {
14983 LogInfo("uDNS_SetupDNSConfig: Purging/Reconfirming Resourcerecord %s, New DNS server %#a, Old DNS server %#a", CRDisplayString(m, cr),
14984 &ptr->addr, (cr->resrec.rDNSServer != mDNSNULL ? &cr->resrec.rDNSServer->addr : mDNSNULL));
14985 PurgeOrReconfirmCacheRecord(m, cr, ptr, mDNSfalse);
14986 }
14987 }
14988
14989 // If a cache record's DNSServer pointer is NULL, but its active question got a DNSServer in this DNS configuration
14990 // update, then use its DNSServer. This way, the active question and its duplicates don't miss out on RMV events.
14991 if (!cr->resrec.rDNSServer && cr->CRActiveQuestion && cr->CRActiveQuestion->qDNSServer)
14992 {
14993 cr->resrec.rDNSServer = cr->CRActiveQuestion->qDNSServer;
14994 LogInfo("uDNS_SetupDNSConfig: Using active question's DNS server %#a for cache record %s", &cr->resrec.rDNSServer->addr, CRDisplayString(m, cr));
14995 }
14996 }
14997
14998 while (*p)
14999 {
15000 if (((*p)->flags & DNSServer_FlagDelete) != 0)
15001 {
15002 // Scan our cache, looking for uDNS records that we would have queried this server for.
15003 // We reconfirm any records that match, because in this world of split DNS, firewalls, etc.
15004 // different DNS servers can give different answers to the same question.
15005 ptr = *p;
15006 FORALL_CACHERECORDS(slot, cg, cr)
15007 {
15008 if (cr->resrec.InterfaceID) continue;
15009 if (cr->resrec.rDNSServer == ptr)
15010 {
15011 // If we don't have an active question for this cache record, neither Purge can
15012 // generate RMV events nor Reconfirm can send queries out. Just set the DNSServer
15013 // pointer on the record NULL so that we don't point to freed memory (We might dereference
15014 // DNSServer pointers from resource record for logging purposes).
15015 //
15016 // If there is an active question, point to its DNSServer as long as it does not point to the
15017 // freed one. We already went through the questions above and made them point at either the
15018 // new server or NULL if there is no server.
15019
15020 if (cr->CRActiveQuestion)
15021 {
15022 DNSQuestion *qptr = cr->CRActiveQuestion;
15023
15024 if (qptr->qDNSServer == ptr)
15025 {
15026 LogMsg("uDNS_SetupDNSConfig: ERROR!! Cache Record %s Active question %##s (%s) (scope:%p) pointing to DNSServer Address %#a"
15027 " to be freed", CRDisplayString(m, cr), qptr->qname.c, DNSTypeName(qptr->qtype), qptr->InterfaceID, &ptr->addr);
15028 qptr->validDNSServers = zeroOpaque128;
15029 qptr->qDNSServer = mDNSNULL;
15030 cr->resrec.rDNSServer = mDNSNULL;
15031 }
15032 else
15033 {
15034 LogInfo("uDNS_SetupDNSConfig: Cache Record %s, Active question %##s (%s) (scope:%p), pointing to DNSServer %#a (to be deleted),"
15035 " resetting to question's DNSServer Address %#a", CRDisplayString(m, cr), qptr->qname.c, DNSTypeName(qptr->qtype),
15036 qptr->InterfaceID, &ptr->addr, (qptr->qDNSServer) ? &qptr->qDNSServer->addr : mDNSNULL);
15037 cr->resrec.rDNSServer = qptr->qDNSServer;
15038 }
15039 }
15040 else
15041 {
15042 LogInfo("uDNS_SetupDNSConfig: Cache Record %##s has no Active question, Record's DNSServer Address %#a, Server to be deleted %#a",
15043 cr->resrec.name, &cr->resrec.rDNSServer->addr, &ptr->addr);
15044 cr->resrec.rDNSServer = mDNSNULL;
15045 }
15046
15047 PurgeOrReconfirmCacheRecord(m, cr, ptr, mDNStrue);
15048 }
15049 }
15050 *p = (*p)->next;
15051 LogInfo("uDNS_SetupDNSConfig: Deleting server %p %#a:%d (%##s) %d", ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c, NumUnicastDNSServers);
15052 mDNSPlatformMemFree(ptr);
15053 }
15054 else
15055 {
15056 (*p)->flags &= ~DNSServer_FlagNew;
15057 p = &(*p)->next;
15058 }
15059 }
15060
15061 // If we now have no DNS servers at all and we used to have some, then immediately purge all unicast cache records (including for LLQs).
15062 // This is important for giving prompt remove events when the user disconnects the Ethernet cable or turns off wireless.
15063 // Otherwise, stale data lingers for 5-10 seconds, which is not the user-experience people expect from Bonjour.
15064 // Similarly, if we now have some DNS servers and we used to have none, we want to purge any fake negative results we may have generated.
15065 if ((m->DNSServers != mDNSNULL) != (oldServers != mDNSNULL))
15066 {
15067 int count = 0;
15068 FORALL_CACHERECORDS(slot, cg, cr)
15069 {
15070 if (!cr->resrec.InterfaceID)
15071 {
15072 mDNS_PurgeCacheResourceRecord(m, cr);
15073 count++;
15074 }
15075 }
15076 LogInfo("uDNS_SetupDNSConfig: %s available; purged %d unicast DNS records from cache",
15077 m->DNSServers ? "DNS server became" : "No DNS servers", count);
15078
15079 // Force anything that needs to get zone data to get that information again
15080 RestartRecordGetZoneData(m);
15081 }
15082
15083 SetDynDNSHostNameIfChanged(m, &fqdn);
15084
15085 mDNS_Unlock(m);
15086
15087 // handle router and primary interface changes
15088 v4 = v6 = r = zeroAddr;
15089 v4.type = r.type = mDNSAddrType_IPv4;
15090
15091 if (mDNSPlatformGetPrimaryInterface(&v4, &v6, &r) == mStatus_NoError && !mDNSv4AddressIsLinkLocal(&v4.ip.v4))
15092 {
15093 mDNS_SetPrimaryInterfaceInfo(m,
15094 !mDNSIPv4AddressIsZero(v4.ip.v4) ? &v4 : mDNSNULL,
15095 !mDNSIPv6AddressIsZero(v6.ip.v6) ? &v6 : mDNSNULL,
15096 !mDNSIPv4AddressIsZero(r.ip.v4) ? &r : mDNSNULL);
15097 }
15098 else
15099 {
15100 mDNS_SetPrimaryInterfaceInfo(m, mDNSNULL, mDNSNULL, mDNSNULL);
15101 if (m->FQDN.c[0]) mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); // Set status to 1 to indicate temporary failure
15102 }
15103
15104 debugf("uDNS_SetupDNSConfig: number of unicast DNS servers %d", NumUnicastDNSServers);
15105 return mStatus_NoError;
15106}
15107
15108mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result)
15109{
15110 m->mDNSPlatformStatus = result;
15111 if (m->MainCallback)
15112 {
15113 mDNS_Lock(m);
15114 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
15115 m->MainCallback(m, mStatus_NoError);
15116 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
15117 mDNS_Unlock(m);
15118 }
15119}
15120
15121mDNSlocal void DeregLoop(mDNS *const m, AuthRecord *const start)
15122{
15123 m->CurrentRecord = start;
15124 while (m->CurrentRecord)
15125 {
15126 AuthRecord *rr = m->CurrentRecord;
15127 LogInfo("DeregLoop: %s deregistration for %p %02X %s",
15128 (rr->resrec.RecordType != kDNSRecordTypeDeregistering) ? "Initiating " : "Accelerating",
15129 rr, rr->resrec.RecordType, ARDisplayString(m, rr));
15130 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering)
15131 mDNS_Deregister_internal(m, rr, mDNS_Dereg_rapid);
15132 else if (rr->AnnounceCount > 1)
15133 {
15134 rr->AnnounceCount = 1;
15135 rr->LastAPTime = m->timenow - rr->ThisAPInterval;
15136 }
15137 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
15138 // new records could have been added to the end of the list as a result of that call.
15139 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now
15140 m->CurrentRecord = rr->next;
15141 }
15142}
15143
15144mDNSexport void mDNS_StartExit(mDNS *const m)
15145{
15146 AuthRecord *rr;
15147
15148 mDNS_Lock(m);
15149
15150 LogInfo("mDNS_StartExit");
15151 m->ShutdownTime = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5);
15152
15153 mDNSCoreBeSleepProxyServer_internal(m, 0, 0, 0, 0, 0);
15154
15155#if APPLE_OSX_mDNSResponder
15156#if !NO_WCF
15157 CHECK_WCF_FUNCTION(WCFConnectionDealloc)
15158 {
15159 if (m->WCF) WCFConnectionDealloc((WCFConnection *)m->WCF);
15160 }
15161#endif
15162#endif
15163
15164#ifndef UNICAST_DISABLED
15165 {
15166 SearchListElem *s;
15167 SuspendLLQs(m);
15168 // Don't need to do SleepRecordRegistrations() here
15169 // because we deregister all records and services later in this routine
15170 while (m->Hostnames) mDNS_RemoveDynDNSHostName(m, &m->Hostnames->fqdn);
15171
15172 // For each member of our SearchList, deregister any records it may have created, and cut them from the list.
15173 // Otherwise they'll be forcibly deregistered for us (without being cut them from the appropriate list)
15174 // and we may crash because the list still contains dangling pointers.
15175 for (s = SearchList; s; s = s->next)
15176 while (s->AuthRecs)
15177 {
15178 ARListElem *dereg = s->AuthRecs;
15179 s->AuthRecs = s->AuthRecs->next;
15180 mDNS_Deregister_internal(m, &dereg->ar, mDNS_Dereg_normal); // Memory will be freed in the FreeARElemCallback
15181 }
15182 }
15183#endif
15184
15185 DeadvertiseAllInterfaceRecords(m);
15186
15187 // Shut down all our active NAT Traversals
15188 while (m->NATTraversals)
15189 {
15190 NATTraversalInfo *t = m->NATTraversals;
15191 mDNS_StopNATOperation_internal(m, t); // This will cut 't' from the list, thereby advancing m->NATTraversals in the process
15192
15193 // After stopping the NAT Traversal, we zero out the fields.
15194 // This has particularly important implications for our AutoTunnel records --
15195 // when we deregister our AutoTunnel records below, we don't want their mStatus_MemFree
15196 // handlers to just turn around and attempt to re-register those same records.
15197 // Clearing t->ExternalPort/t->RequestedPort will cause the mStatus_MemFree callback handlers
15198 // to not do this.
15199 t->ExternalAddress = zerov4Addr;
15200 t->NewAddress = zerov4Addr;
15201 t->ExternalPort = zeroIPPort;
15202 t->RequestedPort = zeroIPPort;
15203 t->Lifetime = 0;
15204 t->Result = mStatus_NoError;
15205 }
15206
15207 // Make sure there are nothing but deregistering records remaining in the list
15208 if (m->CurrentRecord)
15209 LogMsg("mDNS_StartExit: ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
15210
15211 // We're in the process of shutting down, so queries, etc. are no longer available.
15212 // Consequently, determining certain information, e.g. the uDNS update server's IP
15213 // address, will not be possible. The records on the main list are more likely to
15214 // already contain such information, so we deregister the duplicate records first.
15215 LogInfo("mDNS_StartExit: Deregistering duplicate resource records");
15216 DeregLoop(m, m->DuplicateRecords);
15217 LogInfo("mDNS_StartExit: Deregistering resource records");
15218 DeregLoop(m, m->ResourceRecords);
15219
15220 // If we scheduled a response to send goodbye packets, we set NextScheduledResponse to now. Normally when deregistering records,
15221 // we allow up to 100ms delay (to help improve record grouping) but when shutting down we don't want any such delay.
15222 if (m->NextScheduledResponse - m->timenow < mDNSPlatformOneSecond)
15223 {
15224 m->NextScheduledResponse = m->timenow;
15225 m->SuppressSending = 0;
15226 }
15227
15228 if (m->ResourceRecords) LogInfo("mDNS_StartExit: Sending final record deregistrations");
15229 else LogInfo("mDNS_StartExit: No deregistering records remain");
15230
15231 for (rr = m->DuplicateRecords; rr; rr = rr->next)
15232 LogMsg("mDNS_StartExit: Should not still have Duplicate Records remaining: %02X %s", rr->resrec.RecordType, ARDisplayString(m, rr));
15233
15234 // If any deregistering records remain, send their deregistration announcements before we exit
15235 if (m->mDNSPlatformStatus != mStatus_NoError) DiscardDeregistrations(m);
15236
15237 mDNS_Unlock(m);
15238
15239 LogInfo("mDNS_StartExit: done");
15240}
15241
15242mDNSexport void mDNS_FinalExit(mDNS *const m)
15243{
15244 mDNSu32 rrcache_active = 0;
15245 mDNSu32 rrcache_totalused = m->rrcache_totalused;
15246 mDNSu32 slot;
15247 AuthRecord *rr;
15248
15249 LogInfo("mDNS_FinalExit: mDNSPlatformClose");
15250 mDNSPlatformClose(m);
15251
15252 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
15253 {
15254 while (m->rrcache_hash[slot])
15255 {
15256 CacheGroup *cg = m->rrcache_hash[slot];
15257 while (cg->members)
15258 {
15259 CacheRecord *cr = cg->members;
15260 cg->members = cg->members->next;
15261 if (cr->CRActiveQuestion) rrcache_active++;
15262 ReleaseCacheRecord(m, cr);
15263 }
15264 cg->rrcache_tail = &cg->members;
15265 ReleaseCacheGroup(m, &m->rrcache_hash[slot]);
15266 }
15267 }
15268 debugf("mDNS_FinalExit: RR Cache was using %ld records, %lu active", rrcache_totalused, rrcache_active);
15269 if (rrcache_active != m->rrcache_active)
15270 LogMsg("*** ERROR *** rrcache_totalused %lu; rrcache_active %lu != m->rrcache_active %lu", rrcache_totalused, rrcache_active, m->rrcache_active);
15271
15272 for (rr = m->ResourceRecords; rr; rr = rr->next)
15273 LogMsg("mDNS_FinalExit failed to send goodbye for: %p %02X %s", rr, rr->resrec.RecordType, ARDisplayString(m, rr));
15274
15275 LogInfo("mDNS_FinalExit: done");
15276}
15277
15278#ifdef UNIT_TEST
15279#include "../unittests/mdns_ut.c"
15280#endif
15281